From 347dbf123d74cd0bdd36c0b9fd1b87920ec8d087 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 17:56:33 -0400 Subject: [PATCH 01/82] androidmedia: Add androidmedia plugin --- sys/androidcamera/Makefile.am | 74 ++++++++++++++++++++++++++++ sys/androidcamera/gst-androidmedia.c | 49 ++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 sys/androidcamera/Makefile.am create mode 100644 sys/androidcamera/gst-androidmedia.c diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am new file mode 100644 index 0000000000..b10a327601 --- /dev/null +++ b/sys/androidcamera/Makefile.am @@ -0,0 +1,74 @@ +plugin_LTLIBRARIES = libgstandroidmedia.la + +VIDEO_BASE_CLASSES_C = + video/video.c \ + video/gstvideodecoder.c \ + video/gstvideoencoder.c \ + video/gstvideoutils.c +VIDEO_BASE_CLASSES_H = + video/video.h \ + video/gstvideodecoder.h \ + video/gstvideoencoder.h \ + video/gstvideoutils.h + +libgstandroidmedia_la_SOURCES = \ + gst-androidmedia.c \ + gstamc.c \ + gstamcaudiodec.c \ + gstamcvideodec.c \ + video/video.c \ + video/gstvideodecoder.c \ + video/gstvideoencoder.c \ + video/gstvideoutils.c + +noinst_HEADERS = \ + gstamc.h \ + gstamc-constants.h \ + gstamcaudiodec.h \ + gstamcvideodec.h \ + video/video.h \ + video/gstvideodecoder.h \ + video/gstvideoencoder.h \ + video/gstvideoutils.h + +if !HAVE_GST_0_10_37 +libgstandroidmedia_la_SOURCES += $(VIDEO_BASE_CLASSES_C) +noinst_HEADERS += $(VIDEO_BASE_CLASSES_H) +endif + +libgstandroidmedia_la_CFLAGS = \ + $(GST_PLUGINS_BASE_CFLAGS) \ + $(GST_BASE_CFLAGS) \ + $(GST_CFLAGS) \ + $(ORC_CFLAGS) \ + $(JAVA_CFLAGS) \ + -I$(srcdir) +libgstandroidmedia_la_LIBADD = \ + $(GST_PLUGINS_BASE_LIBS) \ + -lgstaudio-@GST_MAJORMINOR@ \ + -lgstpbutils-@GST_MAJORMINOR@ \ + -lgstvideo-@GST_MAJORMINOR@ \ + $(GST_BASE_LIBS) \ + $(GST_LIBS) \ + $(ORC_LIBS) +libgstandroidmedia_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) +if !GST_PLUGIN_BUILD_STATIC +libgstandroidmedia_la_LIBTOOLFLAGS = --tag=disable-static +endif + +EXTRA_DIST = $(VIDEO_BASE_CLASSES_C) $(VIDEO_BASE_CLASSES_H) + +Android.mk: Makefile.am $(BUILT_SOURCES) + androgenizer \ + -:PROJECT libgstandroidmedia -:SHARED libgstandroidmedia \ + -:TAGS eng debug \ + -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \ + -:SOURCES $(libgstandroidmedia_la_SOURCES) \ + $(nodist_libgstandroidmedia_la_SOURCES) \ + -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstandroidmedia_la_CFLAGS) \ + -:LDFLAGS $(libgstandroidmedia_la_LDFLAGS) \ + $(libgstandroidmedia_la_LIBADD) \ + -ldl \ + -:PASSTHROUGH LOCAL_ARM_MODE:=arm \ + LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-@GST_MAJOR_MINOR@' \ + > $@ diff --git a/sys/androidcamera/gst-androidmedia.c b/sys/androidcamera/gst-androidmedia.c new file mode 100644 index 0000000000..065f5525b3 --- /dev/null +++ b/sys/androidcamera/gst-androidmedia.c @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstamc.h" + +#include + +static gboolean +plugin_init (GstPlugin * plugin) +{ + return gst_amc_init (plugin); +} + +#ifdef GST_PLUGIN_DEFINE2 +GST_PLUGIN_DEFINE2 (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + androidmedia, + "Android Media plugin", + plugin_init, + PACKAGE_VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) +#else +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "androidmedia", + "Android Media plugin", + plugin_init, + PACKAGE_VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) +#endif From 21f60289db259c1f2a9617d4d1525aed8acaadab Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 02/82] Adding Dalvik Virtual Machine routines and macros --- sys/androidcamera/Makefile.am | 6 +- sys/androidcamera/gst-dvm.c | 159 ++++++++++++++++++++++++++++++++++ sys/androidcamera/gst-dvm.h | 103 ++++++++++++++++++++++ 3 files changed, 266 insertions(+), 2 deletions(-) create mode 100644 sys/androidcamera/gst-dvm.c create mode 100644 sys/androidcamera/gst-dvm.h diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index b10a327601..daf9ca29f4 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -19,7 +19,8 @@ libgstandroidmedia_la_SOURCES = \ video/video.c \ video/gstvideodecoder.c \ video/gstvideoencoder.c \ - video/gstvideoutils.c + video/gstvideoutils.c \ + gst-dvm.c noinst_HEADERS = \ gstamc.h \ @@ -29,7 +30,8 @@ noinst_HEADERS = \ video/video.h \ video/gstvideodecoder.h \ video/gstvideoencoder.h \ - video/gstvideoutils.h + video/gstvideoutils.h \ + gst-dvm.h if !HAVE_GST_0_10_37 libgstandroidmedia_la_SOURCES += $(VIDEO_BASE_CLASSES_C) diff --git a/sys/androidcamera/gst-dvm.c b/sys/androidcamera/gst-dvm.c new file mode 100644 index 0000000000..df2209ba52 --- /dev/null +++ b/sys/androidcamera/gst-dvm.c @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gst-dvm.h" + +#include + +GST_DEBUG_CATEGORY (gst_dvm_debug); +#define GST_CAT_DEFAULT gst_dvm_debug + +static GModule *java_module; +static jint (*get_created_java_vms) (JavaVM ** vmBuf, jsize bufLen, + jsize * nVMs); +static jint (*create_java_vm) (JavaVM ** p_vm, JNIEnv ** p_env, void *vm_args); +static JavaVM *java_vm = NULL; +static gboolean started_java_vm = FALSE; + +static pthread_key_t current_jni_env; + +static JNIEnv * +gst_dvm_attach_current_thread (void) +{ + JNIEnv *env; + JavaVMAttachArgs args; + + GST_DEBUG ("Attaching thread %p", g_thread_self ()); + args.version = JNI_VERSION_1_6; + 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 +gst_dvm_detach_current_thread (void *env) +{ + GST_DEBUG ("Detaching thread %p", g_thread_self ()); + (*java_vm)->DetachCurrentThread (java_vm); +} + +JNIEnv * +gst_dvm_get_env (void) +{ + JNIEnv *env; + + if ((env = pthread_getspecific (current_jni_env)) == NULL) { + env = gst_dvm_attach_current_thread (); + pthread_setspecific (current_jni_env, env); + } + + return env; +} + +gboolean +gst_dvm_init (void) +{ + jsize n_vms; + + GST_DEBUG_CATEGORY_INIT (gst_dvm_debug, "dvm", 0, "DVM"); + + pthread_key_create (¤t_jni_env, gst_dvm_detach_current_thread); + + java_module = g_module_open ("libdvm", G_MODULE_BIND_LOCAL); + if (!java_module) + goto load_failed; + + if (!g_module_symbol (java_module, "JNI_CreateJavaVM", + (gpointer *) & create_java_vm)) + goto symbol_error; + + if (!g_module_symbol (java_module, "JNI_GetCreatedJavaVMs", + (gpointer *) & get_created_java_vms)) + goto symbol_error; + + n_vms = 0; + if (get_created_java_vms (&java_vm, 1, &n_vms) < 0) + goto get_created_failed; + + if (n_vms > 0) { + GST_DEBUG ("Successfully got existing Java VM %p", java_vm); + } else { + JNIEnv *env; + JavaVMInitArgs vm_args; + JavaVMOption options[4]; + + options[0].optionString = "-verbose:jni"; + options[1].optionString = "-verbose:gc"; + options[2].optionString = "-Xcheck:jni"; + options[3].optionString = "-Xdebug"; + + vm_args.version = JNI_VERSION_1_4; + vm_args.options = options; + vm_args.nOptions = 4; + vm_args.ignoreUnrecognized = JNI_TRUE; + if (create_java_vm (&java_vm, &env, &vm_args) < 0) + goto create_failed; + GST_DEBUG ("Successfully created Java VM %p", java_vm); + + started_java_vm = TRUE; + } + + return java_vm != NULL; + +load_failed: + { + GST_ERROR ("Failed to load libdvm: %s", g_module_error ()); + return FALSE; + } +symbol_error: + { + GST_ERROR ("Failed to locate required JNI symbols in libdvm: %s", + g_module_error ()); + g_module_close (java_module); + java_module = NULL; + return FALSE; + } +get_created_failed: + { + GST_ERROR ("Failed to get already created VMs"); + g_module_close (java_module); + java_module = NULL; + return FALSE; + } +create_failed: + { + GST_ERROR ("Failed to create a Java VM"); + g_module_close (java_module); + java_module = NULL; + return FALSE; + } +} diff --git a/sys/androidcamera/gst-dvm.h b/sys/androidcamera/gst-dvm.h new file mode 100644 index 0000000000..4cef357a9e --- /dev/null +++ b/sys/androidcamera/gst-dvm.h @@ -0,0 +1,103 @@ +/* Dalvik Virtual Machine helper functions + * + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_DVM_H__ +#define __GST_DVM_H__ + +#include +#include + +#define GST_DVM_GET_CLASS(k, name) { \ + jclass tmp; \ + \ + tmp = (*env)->FindClass (env, name); \ + if (!tmp) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get class %s", name); \ + return FALSE; \ + } \ + \ + k.klass = (*env)->NewGlobalRef (env, tmp); \ + if (!k.klass) { \ + (*env)->ExceptionClear (env); \ + (*env)->DeleteLocalRef (env, tmp); \ + GST_ERROR ("Failed to get %s class global reference", name); \ + return FALSE; \ + } \ + (*env)->DeleteLocalRef (env, tmp); \ + } +#define GST_DVM_GET_STATIC_METHOD(k, method, signature) \ + k.method = (*env)->GetStaticMethodID (env, k.klass, #method, \ + signature); \ + if (!k.method) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get static method %s for %s", #method, #k); \ + return FALSE; \ + } + +#define GST_DVM_GET_METHOD(k, method, signature) \ + k.method = (*env)->GetMethodID (env, k.klass, #method, signature); \ + if (!k.method) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get method %s for %s", #method, #k); \ + return FALSE; \ + } + +#define GST_DVM_GET_CONSTRUCTOR(k, field, signature) \ + k.field = (*env)->GetMethodID (env, k.klass, "", signature); \ + if (!k.field) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get constructor %s for %s", #field, #k); \ + return FALSE; \ + } + +#define GST_DVM_GET_FIELD(k, field, signature) \ + k.field = (*env)->GetFieldID (env, k.klass, #field, signature); \ + if (!k.field) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get field %s for %s", #field, #k); \ + return FALSE; \ + } + +#define GST_DVM_GET_CONSTANT(k, field, type, signature) { \ + jfieldID id; \ + \ + id = (*env)->GetStaticFieldID (env, k.klass, #field, signature); \ + if (!id) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get static field %s for %s", #field, #k); \ + return FALSE; \ + } \ + k.field = (*env)->GetStatic##type##Field (env, k.klass, id); \ + if ((*env)->ExceptionCheck (env)) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get " #type " constant %s", #field); \ + return FALSE; \ + } \ + } + + +JNIEnv *gst_dvm_get_env (void); +gboolean gst_dvm_init (void); + +#endif /* __GST_DVM_H__ */ From 4b975b204c44cfd70ccf8d7053cd6e4e3d68b39d Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 03/82] Add android.hardware.Camera (and deps) JNI wrappers --- sys/androidcamera/Makefile.am | 10 +- .../gst-android-graphics-imageformat.c | 98 ++ .../gst-android-graphics-imageformat.h | 45 + .../gst-android-graphics-surfacetexture.c | 93 ++ .../gst-android-graphics-surfacetexture.h | 46 + .../gst-android-hardware-camera.c | 997 ++++++++++++++++++ .../gst-android-hardware-camera.h | 124 +++ 7 files changed, 1411 insertions(+), 2 deletions(-) create mode 100644 sys/androidcamera/gst-android-graphics-imageformat.c create mode 100644 sys/androidcamera/gst-android-graphics-imageformat.h create mode 100644 sys/androidcamera/gst-android-graphics-surfacetexture.c create mode 100644 sys/androidcamera/gst-android-graphics-surfacetexture.h create mode 100644 sys/androidcamera/gst-android-hardware-camera.c create mode 100644 sys/androidcamera/gst-android-hardware-camera.h diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index daf9ca29f4..a0b9752687 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -20,7 +20,10 @@ libgstandroidmedia_la_SOURCES = \ video/gstvideodecoder.c \ video/gstvideoencoder.c \ video/gstvideoutils.c \ - gst-dvm.c + gst-dvm.c \ + gst-android-hardware-camera.c \ + gst-android-graphics-surfacetexture.c \ + gst-android-graphics-imageformat.c noinst_HEADERS = \ gstamc.h \ @@ -31,7 +34,10 @@ noinst_HEADERS = \ video/gstvideodecoder.h \ video/gstvideoencoder.h \ video/gstvideoutils.h \ - gst-dvm.h + gst-dvm.h \ + gst-android-hardware-camera.h \ + gst-android-graphics-surfacetexture.h \ + gst-android-graphics-imageformat.h if !HAVE_GST_0_10_37 libgstandroidmedia_la_SOURCES += $(VIDEO_BASE_CLASSES_C) diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c new file mode 100644 index 0000000000..a79f6f0b86 --- /dev/null +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gst-dvm.h" +#include "gst-android-graphics-imageformat.h" + + +static struct +{ + jclass klass; + jmethodID getBitsPerPixel; + jint JPEG; + jint NV16; + jint NV21; + jint RGB_565; + jint UNKNOWN; + jint YUY2; + jint YV12; +} android_graphics_imageformat; + +gint ImageFormat_JPEG; +gint ImageFormat_NV16; +gint ImageFormat_NV21; +gint ImageFormat_RGB_565; +gint ImageFormat_UNKNOWN; +gint ImageFormat_YUY2; +gint ImageFormat_YV12; + +gboolean +gst_android_graphics_imageformat_init () +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.graphics.ImageFormat */ + GST_DVM_GET_CLASS (android_graphics_imageformat, + "android/graphics/ImageFormat"); + GST_DVM_GET_STATIC_METHOD (android_graphics_imageformat, getBitsPerPixel, + "(I)I"); + + GST_DVM_GET_CONSTANT (android_graphics_imageformat, JPEG, Int, "I"); + ImageFormat_JPEG = android_graphics_imageformat.JPEG; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, NV16, Int, "I"); + ImageFormat_NV16 = android_graphics_imageformat.NV16; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, NV21, Int, "I"); + ImageFormat_NV21 = android_graphics_imageformat.NV21; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, RGB_565, Int, "I"); + ImageFormat_RGB_565 = android_graphics_imageformat.RGB_565; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, UNKNOWN, Int, "I"); + ImageFormat_UNKNOWN = android_graphics_imageformat.UNKNOWN; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, YUY2, Int, "I"); + ImageFormat_YUY2 = android_graphics_imageformat.YUY2; + GST_DVM_GET_CONSTANT (android_graphics_imageformat, YV12, Int, "I"); + ImageFormat_YV12 = android_graphics_imageformat.YV12; + + return TRUE; +} + + +/* android.graphics.ImageFormat */ +gint +gst_ag_imageformat_get_bits_per_pixel (gint format) +{ + JNIEnv *env = gst_dvm_get_env (); + jint bpp = 0; + + bpp = (*env)->CallStaticIntMethod (env, + android_graphics_imageformat.klass, + android_graphics_imageformat.getBitsPerPixel, format); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return -1; + } + + return bpp; +} diff --git a/sys/androidcamera/gst-android-graphics-imageformat.h b/sys/androidcamera/gst-android-graphics-imageformat.h new file mode 100644 index 0000000000..590e828620 --- /dev/null +++ b/sys/androidcamera/gst-android-graphics-imageformat.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_GRAPHICS_IMAGEFORMAT_H__ +#define __GST_ANDROID_GRAPHICS_IMAGEFORMAT_H__ + +#include +#include + + + +/* android.graphics.ImageFormat */ +extern gint ImageFormat_JPEG; +extern gint ImageFormat_NV16; +extern gint ImageFormat_NV21; +extern gint ImageFormat_RGB_565; +extern gint ImageFormat_UNKNOWN; +extern gint ImageFormat_YUY2; +extern gint ImageFormat_YV12; + +gboolean gst_android_graphics_imageformat_init (void); + +gint gst_ag_imageformat_get_bits_per_pixel (gint format); + + +#endif /* __GST_ANDROID_GRAPHICS_IMAGEFORMAT_H__ */ + diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c new file mode 100644 index 0000000000..630fd4bc16 --- /dev/null +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gst-dvm.h" +#include "gst-android-graphics-surfacetexture.h" + + +static struct +{ + jclass klass; + jmethodID constructor; + jmethodID release; +} android_graphics_surfacetexture; + +gboolean +gst_android_graphics_surfacetexture_init () +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.graphics.SurfaceTexture */ + GST_DVM_GET_CLASS (android_graphics_surfacetexture, + "android/graphics/SurfaceTexture"); + GST_DVM_GET_CONSTRUCTOR (android_graphics_surfacetexture, constructor, + "(I)V"); + GST_DVM_GET_METHOD (android_graphics_surfacetexture, release, "()V"); + + return TRUE; +} + + +/* android.graphics.SurfaceTexture */ +GstAGSurfaceTexture * +gst_ag_surfacetexture_new (gint texture_id) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object = NULL; + GstAGSurfaceTexture *tex = NULL; + + object = (*env)->NewObject (env, + android_graphics_surfacetexture.klass, + android_graphics_surfacetexture.constructor); + if ((*env)->ExceptionCheck (env) || !object) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return NULL; + } + + tex = g_slice_new0 (GstAGSurfaceTexture); + tex->object = (*env)->NewGlobalRef (env, object); + if (!tex->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAGSurfaceTexture, tex); + tex = NULL; + } + (*env)->DeleteLocalRef (env, object); + + return tex; +} + +void +gst_ag_surfacetexture_release (GstAGSurfaceTexture * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_graphics_surfacetexture.release); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAGSurfaceTexture, self); +} diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.h b/sys/androidcamera/gst-android-graphics-surfacetexture.h new file mode 100644 index 0000000000..4d77e874b2 --- /dev/null +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_GRAPHICS_SURFACETEXTURE_H__ +#define __GST_ANDROID_GRAPHICS_SURFACETEXTURE_H__ + +#include +#include + + +typedef struct _GstAGSurfaceTexture GstAGSurfaceTexture; + +/* android.graphics.SurfaceTexture */ +struct _GstAGSurfaceTexture { + /* < private > */ + jobject object; /* global reference */ +}; + + +gboolean gst_android_graphics_surfacetexture_init (void); + +/* android.graphics.SurfaceTexture */ +GstAGSurfaceTexture *gst_ag_surfacetexture_new (gint texture_id); +void gst_ag_surfacetexture_release (GstAGSurfaceTexture *self); + + +#endif /* __GST_ANDROID_GRAPHICS_SURFACETEXTURE_H__ */ + diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c new file mode 100644 index 0000000000..170fafbc81 --- /dev/null +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -0,0 +1,997 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gst-dvm.h" +#include "gst-android-hardware-camera.h" + +static struct +{ + jclass klass; + jmethodID addCallbackBuffer; + jmethodID getCameraInfo; + jmethodID getNumberOfCameras; + jmethodID getParameters; + jmethodID lock; + jmethodID open; + jmethodID reconnect; + jmethodID release; + jmethodID setErrorCallback; + jmethodID setParameters; + jmethodID setPreviewCallbackWithBuffer; + jmethodID setPreviewTexture; + jmethodID startPreview; + jmethodID startSmoothZoom; + jmethodID stopPreview; + jmethodID stopSmoothZoom; + jmethodID unlock; +} android_hardware_camera; + +static struct +{ + jclass klass; + jmethodID constructor; + jfieldID facing; + jfieldID orientation; + jint CAMERA_FACING_BACK; + jint CAMERA_FACING_FRONT; +} android_hardware_camera_camerainfo; +gint CameraInfo_CAMERA_FACING_BACK; +gint CameraInfo_CAMERA_FACING_FRONT; + +static struct +{ + jclass klass; + jfieldID width; + jfieldID height; +} android_hardware_camera_size; + +/* TODO: Add other parameters */ +static struct +{ + jclass klass; + jmethodID flatten; + jmethodID getPreviewFormat; + jmethodID getPreviewFpsRange; + jmethodID getPreviewSize; + jmethodID getSupportedPreviewFormats; + jmethodID getSupportedPreviewFpsRange; + jmethodID getSupportedPreviewSizes; + jmethodID setPreviewFormat; + jmethodID setPreviewFpsRange; + jmethodID setPreviewSize; + jmethodID unflatten; +} android_hardware_camera_parameters; + +static struct +{ + jclass klass; + jmethodID iterator; +} java_util_list; + +static struct +{ + jclass klass; + jmethodID hasNext; + jmethodID next; +} java_util_iterator; + +static struct +{ + jclass klass; + jmethodID intValue; +} java_lang_integer; + +static struct +{ + jclass klass; + jmethodID constructor; +} com_gstreamer_gstahccallback; + +static void +gst_ah_camera_on_preview_frame (JNIEnv * env, jclass klass, jbyteArray data, + jobject camera, jlong callback, jlong user_data) +{ + GstAHCPreviewCallback cb = (GstAHCPreviewCallback) (gsize) callback; + + cb (data, (gpointer) (gsize) user_data); +} + +static void +gst_ah_camera_on_error (JNIEnv * env, jclass klass, jint error, + jobject camera, jlong callback, jlong user_data) +{ + GstAHCErrorCallback cb = (GstAHCErrorCallback) (gsize) callback; + + cb (error, (gpointer) (gsize) user_data); +} + +static JNINativeMethod native_methods[] = { + {"gst_ah_camera_on_preview_frame", "([BLandroid/hardware/Camera;JJ)V", + (void *) gst_ah_camera_on_preview_frame}, + {"gst_ah_camera_on_error", "(ILandroid/hardware/Camera;JJ)V", + (void *) gst_ah_camera_on_error} +}; + +gboolean +gst_android_hardware_camera_init () +{ + JNIEnv *env = gst_dvm_get_env (); + + if (!gst_android_graphics_surfacetexture_init ()) + return FALSE; + if (!gst_android_graphics_imageformat_init ()) + return FALSE; + + /* android.hardware.Camera */ + GST_DVM_GET_CLASS (android_hardware_camera, "android/hardware/Camera"); + GST_DVM_GET_METHOD (android_hardware_camera, addCallbackBuffer, "([B)V"); + GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getCameraInfo, + "(ILandroid/hardware/Camera$CameraInfo;)V"); + GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getNumberOfCameras, + "()I"); + GST_DVM_GET_METHOD (android_hardware_camera, getParameters, + "()Landroid/hardware/Camera$Parameters;"); + GST_DVM_GET_METHOD (android_hardware_camera, lock, "()V"); + GST_DVM_GET_STATIC_METHOD (android_hardware_camera, open, + "(I)Landroid/hardware/Camera;"); + GST_DVM_GET_METHOD (android_hardware_camera, reconnect, "()V"); + GST_DVM_GET_METHOD (android_hardware_camera, release, "()V"); + GST_DVM_GET_METHOD (android_hardware_camera, setErrorCallback, + "(Landroid/hardware/Camera$ErrorCallback;)V"); + GST_DVM_GET_METHOD (android_hardware_camera, setParameters, + "(Landroid/hardware/Camera$Parameters;)V"); + GST_DVM_GET_METHOD (android_hardware_camera, setPreviewCallbackWithBuffer, + "(Landroid/hardware/Camera$PreviewCallback;)V"); + GST_DVM_GET_METHOD (android_hardware_camera, setPreviewTexture, + "(Landroid/graphics/SurfaceTexture;)V"); + GST_DVM_GET_METHOD (android_hardware_camera, startPreview, "()V"); + GST_DVM_GET_METHOD (android_hardware_camera, startSmoothZoom, "(I)V"); + GST_DVM_GET_METHOD (android_hardware_camera, stopPreview, "()V"); + GST_DVM_GET_METHOD (android_hardware_camera, stopSmoothZoom, "()V"); + GST_DVM_GET_METHOD (android_hardware_camera, unlock, "()V"); + + /* android.hardware.Camera.CameraInfo */ + GST_DVM_GET_CLASS (android_hardware_camera_camerainfo, + "android/hardware/Camera$CameraInfo"); + GST_DVM_GET_CONSTRUCTOR (android_hardware_camera_camerainfo, + constructor, "()V"); + GST_DVM_GET_FIELD (android_hardware_camera_camerainfo, facing, "I"); + GST_DVM_GET_FIELD (android_hardware_camera_camerainfo, orientation, "I"); + GST_DVM_GET_CONSTANT (android_hardware_camera_camerainfo, CAMERA_FACING_BACK, + Int, "I"); + CameraInfo_CAMERA_FACING_BACK = + android_hardware_camera_camerainfo.CAMERA_FACING_BACK; + GST_DVM_GET_CONSTANT (android_hardware_camera_camerainfo, CAMERA_FACING_FRONT, + Int, "I"); + CameraInfo_CAMERA_FACING_FRONT = + android_hardware_camera_camerainfo.CAMERA_FACING_FRONT; + + /* android.hardware.Camera.Size */ + GST_DVM_GET_CLASS (android_hardware_camera_size, + "android/hardware/Camera$Size"); + GST_DVM_GET_FIELD (android_hardware_camera_size, width, "I"); + GST_DVM_GET_FIELD (android_hardware_camera_size, height, "I"); + + /* android.hardware.Camera.Parameters */ + GST_DVM_GET_CLASS (android_hardware_camera_parameters, + "android/hardware/Camera$Parameters"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, flatten, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFormat, + "()I"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFpsRange, + "([I)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewSize, + "()Landroid/hardware/Camera$Size;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedPreviewFormats, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedPreviewFpsRange, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedPreviewSizes, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFormat, + "(I)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFpsRange, + "(II)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewSize, + "(II)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, unflatten, + "(Ljava/lang/String;)V"); + + /* java.util.List */ + GST_DVM_GET_CLASS (java_util_list, "java/util/List"); + GST_DVM_GET_METHOD (java_util_list, iterator, "()Ljava/util/Iterator;"); + + /* java.util.Iterator */ + GST_DVM_GET_CLASS (java_util_iterator, "java/util/Iterator"); + GST_DVM_GET_METHOD (java_util_iterator, hasNext, "()Z"); + GST_DVM_GET_METHOD (java_util_iterator, next, "()Ljava/lang/Object;"); + + /* java.lang.Integer */ + GST_DVM_GET_CLASS (java_lang_integer, "java/lang/Integer"); + GST_DVM_GET_METHOD (java_lang_integer, intValue, "()I"); + + /* com.gstreamer.GstAhcCallback */ + GST_DVM_GET_CLASS (com_gstreamer_gstahccallback, + "com/gstreamer/GstAhcCallback"); + GST_DVM_GET_CONSTRUCTOR (com_gstreamer_gstahccallback, constructor, "(JJ)V"); + + if ((*env)->RegisterNatives (env, com_gstreamer_gstahccallback.klass, + native_methods, G_N_ELEMENTS (native_methods))) { + GST_ERROR ("Failed to register native methods for GstAhcCallback"); + return FALSE; + } + + return TRUE; +} + + +/* android.hardware.Camera */ +void +gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer) +{ + JNIEnv *env = gst_dvm_get_env (); + + /* TODO: use a java.nio.ByteBuffer if possible */ + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.addCallbackBuffer, buffer); +} + +gboolean +gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject jcamera_info = NULL; + gboolean ret = TRUE; + + jcamera_info = (*env)->NewObject (env, + android_hardware_camera_camerainfo.klass, + android_hardware_camera_camerainfo.constructor); + if (!jcamera_info) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + + (*env)->CallStaticVoidMethod (env, android_hardware_camera.klass, + android_hardware_camera.getCameraInfo, camera_id, jcamera_info); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + + camera_info->facing = (*env)->GetIntField (env, jcamera_info, + android_hardware_camera_camerainfo.facing); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to get CameraInfo.facing field"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + + camera_info->orientation = (*env)->GetIntField (env, jcamera_info, + android_hardware_camera_camerainfo.orientation); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to get CameraInfo.orientation field"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + +done: + if (jcamera_info) + (*env)->DeleteLocalRef (env, jcamera_info); + + return ret; +} + +gint +gst_ah_camera_get_number_of_cameras () +{ + JNIEnv *env = gst_dvm_get_env (); + gint num_cameras; + + num_cameras = (*env)->CallStaticIntMethod (env, android_hardware_camera.klass, + android_hardware_camera.getNumberOfCameras); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return -1; + } + + return num_cameras; +} + +GstAHCParameters * +gst_ah_camera_get_parameters (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object = NULL; + GstAHCParameters *params = NULL; + + object = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera.getParameters); + if ((*env)->ExceptionCheck (env) || !object) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return NULL; + } + + params = g_slice_new0 (GstAHCParameters); + params->object = (*env)->NewGlobalRef (env, object); + if (!params->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCParameters, params); + params = NULL; + } + (*env)->DeleteLocalRef (env, object); + + return params; +} + +gboolean +gst_ah_camera_lock (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, android_hardware_camera.lock); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +GstAHCamera * +gst_ah_camera_open (gint camera_id) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object = NULL; + GstAHCamera *camera = NULL; + + object = (*env)->CallStaticObjectMethod (env, android_hardware_camera.klass, + android_hardware_camera.open, camera_id); + if ((*env)->ExceptionCheck (env) || !object) { + /* TODO: return a GError ? */ + //jthrowable e = (*env)->ExceptionOccurred(env); + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionDescribe (env); + (*env)->ExceptionClear (env); + return NULL; + } + + camera = g_slice_new0 (GstAHCamera); + camera->object = (*env)->NewGlobalRef (env, object); + if (!camera->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCamera, camera); + camera = NULL; + } + (*env)->DeleteLocalRef (env, object); + + return camera; +} + +gboolean +gst_ah_camera_reconnect (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, android_hardware_camera.reconnect); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +void +gst_ah_camera_release (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, android_hardware_camera.release); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAHCamera, self); +} + +gboolean +gst_ah_camera_set_parameters (GstAHCamera * self, GstAHCParameters * params) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.setParameters, params->object); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, + gpointer user_data) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object; + gboolean ret = TRUE; + + object = (*env)->NewObject (env, + com_gstreamer_gstahccallback.klass, + com_gstreamer_gstahccallback.constructor, + *((jlong *) & cb), *((jlong *) & user_data)); + if (!object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.setErrorCallback, object); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + +done: + if (object) + (*env)->DeleteLocalRef (env, object); + + return ret; +} + +gboolean +gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, + GstAHCPreviewCallback cb, gpointer user_data) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object; + gboolean ret = TRUE; + + object = (*env)->NewObject (env, + com_gstreamer_gstahccallback.klass, + com_gstreamer_gstahccallback.constructor, + *((jlong *) & cb), *((jlong *) & user_data)); + if (!object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.setPreviewCallbackWithBuffer, object); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + ret = FALSE; + goto done; + } + +done: + if (object) + (*env)->DeleteLocalRef (env, object); + + return ret; +} + +void +gst_ah_camera_set_preview_texture (GstAHCamera * self, + GstAGSurfaceTexture * surfaceTexture) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.setPreviewTexture, surfaceTexture->object); +} + +gboolean +gst_ah_camera_start_preview (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.startPreview); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ah_camera_start_smooth_zoom (GstAHCamera * self, gint value) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.startSmoothZoom, value); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ah_camera_stop_preview (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.stopPreview); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ah_camera_stop_smooth_zoom (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera.stopSmoothZoom); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ah_camera_unlock (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, android_hardware_camera.unlock); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +/* android.hardware.Camera.Size */ +GstAHCSize * +gst_ahc_size_new (gint width, gint height) +{ + GstAHCSize *self = g_slice_new0 (GstAHCSize); + + self->width = width; + self->height = height; + + return self; +} + +void +gst_ahc_size_free (GstAHCSize * self) +{ + g_slice_free (GstAHCSize, self); +} + + +/* android.hardware.Camera.Parameters */ +gchar * +gst_ahc_parameters_flatten (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring v_str = NULL; + const gchar *v = NULL; + gchar *ret = NULL; + + v_str = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera_parameters.flatten); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + goto done; + } + + v = (*env)->GetStringUTFChars (env, v_str, NULL); + if (!v) { + GST_ERROR ("Failed to convert string to UTF8"); + (*env)->ExceptionClear (env); + goto done; + } + + ret = g_strdup (v); +done: + if (v) + (*env)->ReleaseStringUTFChars (env, v_str, v); + if (v_str) + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +gint +gst_ahc_parameters_get_preview_format (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint format; + + format = (*env)->CallIntMethod (env, self->object, + android_hardware_camera_parameters.getPreviewFormat); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return 0; + } + + return format; +} + +gboolean +gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, + gint * min, gint * max) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = TRUE; + jintArray range = NULL; + jint *fps = NULL; + + range = (*env)->NewIntArray (env, 2); + if (!fps) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to create array"); + ret = FALSE; + goto done; + } + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera_parameters.getPreviewFpsRange, range); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return 0; + } + + fps = (*env)->GetIntArrayElements (env, range, NULL); + if ((*env)->ExceptionCheck (env) || !fps) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array elements"); + ret = FALSE; + goto done; + } + if (min) + *min = fps[0]; + if (max) + *max = fps[1]; + +done: + if (fps) + (*env)->ReleaseIntArrayElements (env, range, fps, JNI_ABORT); + if (range) + (*env)->DeleteLocalRef (env, range); + + return ret; +} + +GstAHCSize * +gst_ahc_parameters_get_preview_size (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject jsize = NULL; + GstAHCSize *size = NULL; + + jsize = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera_parameters.getPreviewSize); + if ((*env)->ExceptionCheck (env) || !jsize) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + goto done; + } + + size = g_slice_new0 (GstAHCSize); + + size->width = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.width); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to get Camera.Size.width field"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCSize, size); + size = NULL; + goto done; + } + + size->height = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.height); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to get Camera.Size.height field"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCSize, size); + size = NULL; + goto done; + } + +done: + if (jsize) + (*env)->DeleteLocalRef (env, jsize); + + return size; +} + +static jobject +java_util_list_iterator (JNIEnv * env, jobject obj) +{ + return (*env)->CallObjectMethod (env, obj, java_util_list.iterator); +} + +static jobject +java_util_iterator_next (JNIEnv * env, jobject obj) +{ + return (*env)->CallObjectMethod (env, obj, java_util_iterator.next); +} + +static jboolean +java_util_iterator_has_next (JNIEnv * env, jobject obj) +{ + return (*env)->CallBooleanMethod (env, obj, java_util_iterator.hasNext); +} + +static jint +java_lang_integer_int_value (JNIEnv * env, jobject obj) +{ + return (*env)->CallIntMethod (env, obj, java_lang_integer.intValue); +} + +GList * +gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera_parameters.getSupportedPreviewFormats); + if ((*env)->ExceptionCheck (env) || !list) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return NULL; + } + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject integer = java_util_iterator_next (env, iterator); + + if (integer) { + jint value = java_lang_integer_int_value (env, integer); + + ret = g_list_append (ret, GINT_TO_POINTER (value)); + (*env)->DeleteLocalRef (env, integer); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_preview_formats_free (GList * list) +{ + g_list_free (list); +} + +GList * +gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera_parameters.getSupportedPreviewFpsRange); + if ((*env)->ExceptionCheck (env) || !list) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return NULL; + } + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jintArray range = java_util_iterator_next (env, iterator); + + if (range) { + jint *fps = malloc (sizeof (jint) * 2); + + (*env)->GetIntArrayRegion (env, range, 0, 2, fps); + ret = g_list_append (ret, fps); + (*env)->DeleteLocalRef (env, range); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_preview_fps_range_free (GList * list) +{ + g_list_free_full (list, (GDestroyNotify) g_free); +} + +GList * +gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = (*env)->CallObjectMethod (env, self->object, + android_hardware_camera_parameters.getSupportedPreviewSizes); + if ((*env)->ExceptionCheck (env) || !list) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return NULL; + } + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject jsize = java_util_iterator_next (env, iterator); + + if (jsize) { + jint width, height; + + width = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.width); + height = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.height); + + ret = g_list_append (ret, gst_ahc_size_new (width, height)); + (*env)->DeleteLocalRef (env, jsize); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_preview_sizes_free (GList * list) +{ + g_list_free_full (list, (GDestroyNotify) gst_ahc_size_free); +} + +gboolean +gst_ahc_parameters_set_preview_format (GstAHCParameters * self, gint format) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera_parameters.setPreviewFormat, format); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_preview_fps_range (GstAHCParameters * self, + gint min, gint max) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera_parameters.setPreviewFpsRange, min, max); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_preview_size (GstAHCParameters * self, + gint width, gint height) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera_parameters.setPreviewSize, width, height); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_ahc_parameters_unflatten (GstAHCParameters * self, gchar * flattened) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring v_str = NULL; + gboolean ret = TRUE; + + v_str = (*env)->NewStringUTF (env, flattened); + if (v_str == NULL) + return FALSE; + + (*env)->CallVoidMethod (env, self->object, + android_hardware_camera_parameters.unflatten, v_str); + if ((*env)->ExceptionCheck (env)) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + ret = FALSE; + } + + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +void +gst_ahc_parameters_free (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAHCParameters, self); +} diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h new file mode 100644 index 0000000000..a83811880b --- /dev/null +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_HARDWARE_CAMERA_H__ +#define __GST_ANDROID_HARDWARE_CAMERA_H__ + +#include +#include + +#include "gst-android-graphics-surfacetexture.h" +#include "gst-android-graphics-imageformat.h" + +typedef struct _GstAHCamera GstAHCamera; +typedef struct _GstAHCCameraInfo GstAHCCameraInfo; +typedef struct _GstAHCSize GstAHCSize; +typedef struct _GstAHCParameters GstAHCParameters; + +/* android.hardware.Camera */ +struct _GstAHCamera { + /* < private > */ + jobject object; /* global reference */ +}; + +/* android.hardware.Camera.CameraInfo */ +struct _GstAHCCameraInfo { + gint facing; + gint orientation; +}; +extern gint CameraInfo_CAMERA_FACING_BACK; +extern gint CameraInfo_CAMERA_FACING_FRONT; + +/* android.hardware.Camera.Size */ +struct _GstAHCSize { + gint width; + gint height; +}; + +/* android.hardware.Camera.Parameters */ +struct _GstAHCParameters { + /* < private > */ + jobject object; /* global reference */ +}; + +/* android.hardware.Camera.ErrorCallback */ +typedef void (*GstAHCErrorCallback) (gint error, gpointer user_data); + +/* android.hardware.Camera.PreviewCallback */ +typedef void (*GstAHCPreviewCallback) (jbyteArray data, gpointer user_data); + +gboolean gst_android_hardware_camera_init (void); + +/* android.hardware.Camera */ +void gst_ah_camera_add_callback_buffer (GstAHCamera *self, + jbyteArray buffer); +gboolean gst_ah_camera_get_camera_info (gint camera_id, + GstAHCCameraInfo *camera_info); +gint gst_ah_camera_get_number_of_cameras (void); +GstAHCParameters *gst_ah_camera_get_parameters (GstAHCamera *self); +gboolean gst_ah_camera_lock (GstAHCamera *self); +GstAHCamera * gst_ah_camera_open (gint camera_id); +gboolean gst_ah_camera_reconnect (GstAHCamera *self); +void gst_ah_camera_release (GstAHCamera *self); +gboolean gst_ah_camera_set_parameters (GstAHCamera *self, + GstAHCParameters *params); +gboolean gst_ah_camera_set_error_callback (GstAHCamera *self, + GstAHCErrorCallback cb, gpointer user_data); +gboolean gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera *self, + GstAHCPreviewCallback cb, gpointer user_data); +void gst_ah_camera_set_preview_texture (GstAHCamera *self, + GstAGSurfaceTexture *surfaceTexture); +gboolean gst_ah_camera_start_preview (GstAHCamera *self); +gboolean gst_ah_camera_start_smooth_zoom (GstAHCamera *self, gint value); +gboolean gst_ah_camera_stop_preview (GstAHCamera *self); +gboolean gst_ah_camera_stop_smooth_zoom (GstAHCamera *self); +gboolean gst_ah_camera_unlock (GstAHCamera *self); + +/* android.hardware.Camera.Size */ +GstAHCSize *gst_ahc_size_new (gint width, gint height); +void gst_ahc_size_free (GstAHCSize *self); + +/* android.hardware.Camera.Parameters */ +gchar * gst_ahc_parameters_flatten (GstAHCParameters *self); +gint gst_ahc_parameters_get_preview_format (GstAHCParameters *self); +gboolean gst_ahc_parameters_get_preview_fps_range (GstAHCParameters *self, + gint *min, gint *max); +GstAHCSize *gst_ahc_parameters_get_preview_size (GstAHCParameters *self); +/* GList */ +GList *gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters *self); +void gst_ahc_parameters_supported_preview_formats_free (GList *list); +/* GList */ +GList *gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters *self); +void gst_ahc_parameters_supported_preview_fps_range_free (GList *list); +/* GList */ +GList *gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters *self); +void gst_ahc_parameters_supported_preview_sizes_free (GList *list); +gboolean gst_ahc_parameters_set_preview_format (GstAHCParameters *self, gint format); +gboolean gst_ahc_parameters_set_preview_fps_range (GstAHCParameters *self, + gint min, gint max); +gboolean gst_ahc_parameters_set_preview_size (GstAHCParameters *self, + gint width, gint height); +gboolean gst_ahc_parameters_unflatten (GstAHCParameters *self, gchar *flattened); +void gst_ahc_parameters_free (GstAHCParameters *self); + + +#endif /* __GST_ANDROID_HARDWARE_CAMERA_H__ */ + From 484b0ae6588b8187f94e98b393c8b44f2dc76b72 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 04/82] Add ahcsrc Camera source element prototype --- sys/androidcamera/Makefile.am | 6 +- sys/androidcamera/gst-androidmedia.c | 19 +- sys/androidcamera/gstahcsrc.c | 412 +++++++++++++++++++++++++++ sys/androidcamera/gstahcsrc.h | 67 +++++ 4 files changed, 499 insertions(+), 5 deletions(-) create mode 100644 sys/androidcamera/gstahcsrc.c create mode 100644 sys/androidcamera/gstahcsrc.h diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index a0b9752687..fce98c7749 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -23,7 +23,8 @@ libgstandroidmedia_la_SOURCES = \ gst-dvm.c \ gst-android-hardware-camera.c \ gst-android-graphics-surfacetexture.c \ - gst-android-graphics-imageformat.c + gst-android-graphics-imageformat.c \ + gstahcsrc.c noinst_HEADERS = \ gstamc.h \ @@ -37,7 +38,8 @@ noinst_HEADERS = \ gst-dvm.h \ gst-android-hardware-camera.h \ gst-android-graphics-surfacetexture.h \ - gst-android-graphics-imageformat.h + gst-android-graphics-imageformat.h \ + gstahcsrc.h if !HAVE_GST_0_10_37 libgstandroidmedia_la_SOURCES += $(VIDEO_BASE_CLASSES_C) diff --git a/sys/androidcamera/gst-androidmedia.c b/sys/androidcamera/gst-androidmedia.c index 065f5525b3..ee42f2b838 100644 --- a/sys/androidcamera/gst-androidmedia.c +++ b/sys/androidcamera/gst-androidmedia.c @@ -22,14 +22,27 @@ #include "config.h" #endif -#include "gstamc.h" - #include +#include "gstamc.h" +#include "gst-dvm.h" +#include "gst-android-hardware-camera.h" +#include "gstahcsrc.h" + static gboolean plugin_init (GstPlugin * plugin) { - return gst_amc_init (plugin); + if (!gst_amc_init (plugin)) + return FALSE; + + if (!gst_dvm_init ()) + return FALSE; + + if (!gst_android_hardware_camera_init ()) + return FALSE; + + return gst_element_register (plugin, "ahcsrc", GST_RANK_NONE, + GST_TYPE_AHC_SRC); } #ifdef GST_PLUGIN_DEFINE2 diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c new file mode 100644 index 0000000000..331b33a628 --- /dev/null +++ b/sys/androidcamera/gstahcsrc.c @@ -0,0 +1,412 @@ +/* GStreamer android.hardware.Camera Source + * + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "gstahcsrc.h" +#include "gst-dvm.h" + +static void gst_ahc_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_ahc_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static void gst_ahc_src_dispose (GObject * object); + +static GstStateChangeReturn gst_ahc_src_change_state (GstElement * element, + GstStateChange transition); +static GstCaps *gst_ahc_src_getcaps (GstBaseSrc * src); +static gboolean gst_ahc_src_start (GstBaseSrc * bsrc); +static gboolean gst_ahc_src_stop (GstBaseSrc * bsrc); +static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); +static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); +static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); + +#define GST_AHC_SRC_CAPS_STR \ + GST_VIDEO_CAPS_YUV (" { YV12 , YUY2 , NV21 , NV16 }") ";" \ + GST_VIDEO_CAPS_RGB_16 + +static GstStaticPadTemplate gst_ahc_src_pad_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (GST_AHC_SRC_CAPS_STR)); + +GST_DEBUG_CATEGORY_STATIC (gst_ahc_src_debug); +#define GST_CAT_DEFAULT gst_ahc_src_debug + +enum +{ + ARG_0, +}; +GST_BOILERPLATE (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC); + +static void +gst_ahc_src_base_init (gpointer g_class) +{ + GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); + + GST_DEBUG_CATEGORY_INIT (gst_ahc_src_debug, "ahcsrc", 0, + "android.hardware.Camera source element"); + + gst_element_class_add_static_pad_template (gstelement_class, + &gst_ahc_src_pad_template); + gst_element_class_set_details_simple (gstelement_class, + "Android Camera Source", + "Source/Video", + "Reads frames from android.hardware.Camera class into buffers", + "Youness Alaoui "); +} + +static void +gst_ahc_src_class_init (GstAHCSrcClass * klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass); + GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass); + + gobject_class->set_property = gst_ahc_src_set_property; + gobject_class->get_property = gst_ahc_src_get_property; + gobject_class->dispose = gst_ahc_src_dispose; + + element_class->change_state = gst_ahc_src_change_state; + + gstbasesrc_class->get_caps = gst_ahc_src_getcaps; + gstbasesrc_class->start = gst_ahc_src_start; + gstbasesrc_class->stop = gst_ahc_src_stop; + gstbasesrc_class->unlock = gst_ahc_src_unlock; + gstbasesrc_class->unlock_stop = gst_ahc_src_unlock_stop; + + gstpushsrc_class->create = gst_ahc_src_create; +} + +static void +gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) +{ + gst_base_src_set_live (GST_BASE_SRC (self), TRUE); + gst_base_src_set_format (GST_BASE_SRC (self), GST_FORMAT_TIME); + gst_base_src_set_do_timestamp (GST_BASE_SRC (self), TRUE); + + self->camera = NULL; + self->texture = gst_ag_surfacetexture_new (0); + self->data = NULL; + self->queue = g_async_queue_new (); + self->caps = NULL; + self->flushing = FALSE; +} + +static void +gst_ahc_src_dispose (GObject * object) +{ + GstAHCSrc *self = GST_AHC_SRC (object); + + if (self->camera) + gst_ah_camera_release (self->camera); + self->camera = NULL; + + if (self->texture) + gst_ag_surfacetexture_release (self->texture); + self->texture = NULL; + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static GstCaps * +gst_ahc_src_getcaps (GstBaseSrc * src) +{ + GstAHCSrc *self = GST_AHC_SRC (src); + + return gst_caps_copy (self->caps); +} + +static void +gst_ahc_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstAHCSrc *self = GST_AHC_SRC (object); + (void) self; + + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_ahc_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstAHCSrc *self = GST_AHC_SRC (object); + (void) self; + + switch (prop_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) +{ + GstAHCSrc *self = GST_AHC_SRC (user_data); + JNIEnv *env = gst_dvm_get_env (); + + //GST_WARNING_OBJECT (self, "Received data buffer %p", data); + g_async_queue_push (self->queue, (*env)->NewGlobalRef (env, data)); +} + +static void +gst_ahc_src_on_error (int error, gpointer user_data) +{ + GstAHCSrc *self = GST_AHC_SRC (user_data); + + GST_WARNING_OBJECT (self, "Received error code : %d", error); + +} + +static gboolean +gst_ahc_src_open (GstAHCSrc * self) +{ + GST_WARNING_OBJECT (self, "Openning camera"); + + self->camera = gst_ah_camera_open (0); + + if (self->camera) { + GstAHCParameters *params; + JNIEnv *env = gst_dvm_get_env (); + + params = gst_ah_camera_get_parameters (self->camera); + + GST_WARNING_OBJECT (self, "Opened camera"); + if (params) { + GstAHCSize *size; + + GST_WARNING_OBJECT (self, "Params : %s", + gst_ahc_parameters_flatten (params)); + gst_ahc_parameters_set_preview_size (params, 640, 480); + gst_ahc_parameters_set_preview_format (params, ImageFormat_NV21); + + GST_WARNING_OBJECT (self, "Setting new params (%d) : %s", + gst_ah_camera_set_parameters (self->camera, params), + gst_ahc_parameters_flatten (params)); + size = gst_ahc_parameters_get_preview_size (params); + self->caps = gst_caps_new_simple ("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '2', '1'), + "width", G_TYPE_INT, size->width, + "height", G_TYPE_INT, size->height, + "framerate", GST_TYPE_FRACTION, 30, 1, NULL); + self->buffer_size = size->width * size->height * + gst_ag_imageformat_get_bits_per_pixel + (gst_ahc_parameters_get_preview_format (params)) / 8; + gst_ahc_size_free (size); + gst_ah_camera_set_preview_texture (self->camera, self->texture); + gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, + self); + gst_ah_camera_set_preview_callback_with_buffer (self->camera, + gst_ahc_src_on_preview_frame, self); + gst_ah_camera_add_callback_buffer (self->camera, + (*env)->NewByteArray (env, self->buffer_size)); + gst_ah_camera_add_callback_buffer (self->camera, + (*env)->NewByteArray (env, self->buffer_size)); + gst_ah_camera_add_callback_buffer (self->camera, + (*env)->NewByteArray (env, self->buffer_size)); + + { + GList *list, *i; + + list = gst_ahc_parameters_get_supported_preview_formats (params); + GST_WARNING_OBJECT (self, "Supported preview formats:"); + for (i = list; i; i = i->next) { + int f = GPOINTER_TO_INT (i->data); + + GST_WARNING_OBJECT (self, " %d", f); + } + gst_ahc_parameters_supported_preview_formats_free (list); + + list = gst_ahc_parameters_get_supported_preview_sizes (params); + GST_WARNING_OBJECT (self, "Supported preview sizes:"); + for (i = list; i; i = i->next) { + GstAHCSize *s = i->data; + + GST_WARNING_OBJECT (self, " %dx%d", s->width, s->height); + } + gst_ahc_parameters_supported_preview_sizes_free (list); + + list = gst_ahc_parameters_get_supported_preview_fps_range (params); + GST_WARNING_OBJECT (self, "Supported preview fps range:"); + for (i = list; i; i = i->next) { + int *range = i->data; + + GST_WARNING_OBJECT (self, " [%d, %d]", range[0], range[1]); + } + gst_ahc_parameters_supported_preview_fps_range_free (list); + } + gst_ahc_parameters_free (params); + } + + } else { + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, + ("Unable to open device '%d'.", 0), GST_ERROR_SYSTEM); + } + + return (self->camera != NULL); +} + +static GstStateChangeReturn +gst_ahc_src_change_state (GstElement * element, GstStateChange transition) +{ + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; + GstAHCSrc *self = GST_AHC_SRC (element); + + GST_WARNING_OBJECT (self, "Changing state %d", transition); + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + { + gint num_cams = gst_ah_camera_get_number_of_cameras (); + gint i; + + GST_WARNING_OBJECT (self, "Found %d cameras on the system", num_cams); + + for (i = 0; i <= num_cams; i++) { + GstAHCCameraInfo info; + if (gst_ah_camera_get_camera_info (i, &info)) { + GST_WARNING_OBJECT (self, "Camera info for %d", i); + GST_WARNING_OBJECT (self, " Facing: %s (%d)", + info.facing == CameraInfo_CAMERA_FACING_BACK ? "Back" : "Front", + info.facing); + GST_WARNING_OBJECT (self, " Orientation: %d degrees", + info.orientation); + } else { + GST_WARNING_OBJECT (self, "Error getting camera info for %d", i); + } + } + + if (num_cams > 0) { + if (!gst_ahc_src_open (self)) + return GST_STATE_CHANGE_FAILURE; + } else { + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, + ("There are no cameras available on this device."), + GST_ERROR_SYSTEM); + return GST_STATE_CHANGE_FAILURE; + } + } + break; + default: + break; + } + + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_READY_TO_NULL: + if (self->camera) + gst_ah_camera_release (self->camera); + self->camera = NULL; + break; + default: + break; + } + + return ret; +} + +static gboolean +gst_ahc_src_start (GstBaseSrc * bsrc) +{ + GstAHCSrc *self = GST_AHC_SRC (bsrc); + + GST_WARNING_OBJECT (self, "Starting preview"); + if (self->camera) { + gboolean ret = gst_ah_camera_start_preview (self->camera); + if (ret) + gst_ah_camera_set_preview_callback_with_buffer (self->camera, + gst_ahc_src_on_preview_frame, self); + return ret; + } else { + return FALSE; + } +} + +static gboolean +gst_ahc_src_stop (GstBaseSrc * bsrc) +{ + GstAHCSrc *self = GST_AHC_SRC (bsrc); + + GST_WARNING_OBJECT (self, "Stopping preview"); + if (self->camera) + return gst_ah_camera_stop_preview (self->camera); + else + return TRUE; +} + +static gboolean +gst_ahc_src_unlock (GstBaseSrc * bsrc) +{ + GstAHCSrc *self = GST_AHC_SRC (bsrc); + + GST_WARNING_OBJECT (self, "Unlocking create"); + self->flushing = TRUE; + + return TRUE; +} + +static gboolean +gst_ahc_src_unlock_stop (GstBaseSrc * bsrc) +{ + GstAHCSrc *self = GST_AHC_SRC (bsrc); + + GST_WARNING_OBJECT (self, "Stopping unlock"); + self->flushing = FALSE; + + return TRUE; +} + +static GstFlowReturn +gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) +{ + GstAHCSrc *self = GST_AHC_SRC (src); + JNIEnv *env = gst_dvm_get_env (); + jbyteArray data = NULL; + + while (data == NULL) { + data = g_async_queue_timeout_pop (self->queue, 100000); + if (data == NULL && self->flushing) + return GST_FLOW_WRONG_STATE; + } + + *buffer = gst_buffer_new_and_alloc (self->buffer_size); + (*env)->GetByteArrayRegion (env, data, 0, self->buffer_size, + (jbyte *) GST_BUFFER_DATA (*buffer)); + gst_buffer_set_caps (*buffer, self->caps); + + gst_ah_camera_add_callback_buffer (self->camera, data); + (*env)->DeleteGlobalRef (env, data); + + return GST_FLOW_OK; +} diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h new file mode 100644 index 0000000000..664b058897 --- /dev/null +++ b/sys/androidcamera/gstahcsrc.h @@ -0,0 +1,67 @@ +/* GStreamer android.hardware.Camera Source + * + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GST_AHC_SRC_H__ +#define __GST_AHC_SRC_H__ + +#include +#include +#include "gst-android-hardware-camera.h" + +G_BEGIN_DECLS + +#define GST_TYPE_AHC_SRC \ + (gst_ahc_src_get_type()) +#define GST_AHC_SRC(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_AHC_SRC, GstAHCSrc)) +#define GST_AHC_SRC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_AHC_SRC, GstAHCSrcClass)) +#define GST_IS_AHC_SRC(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_AHC_SRC)) +#define GST_IS_AHC_SRC_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_AHC_SRC)) + + +typedef struct _GstAHCSrc GstAHCSrc; +typedef struct _GstAHCSrcClass GstAHCSrcClass; + +struct _GstAHCSrc +{ + GstPushSrc parent; + + GstAHCamera *camera; + GstAGSurfaceTexture *texture; + GstCaps *caps; + GList *data; + GAsyncQueue *queue; + gint buffer_size; + gboolean flushing; +}; + +struct _GstAHCSrcClass +{ + GstPushSrcClass parent_class; +}; + +GType gst_ahc_src_get_type (void); + +G_END_DECLS +#endif /* __GST_AHC_SRC_H__ */ From 37685f09e048cbba3b50d764c5c65ef7e228b5d5 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 05/82] SurfaceTexture constructure needs texture_id --- sys/androidcamera/gst-android-graphics-surfacetexture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index 630fd4bc16..432f12034a 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -60,7 +60,7 @@ gst_ag_surfacetexture_new (gint texture_id) object = (*env)->NewObject (env, android_graphics_surfacetexture.klass, - android_graphics_surfacetexture.constructor); + android_graphics_surfacetexture.constructor, texture_id); if ((*env)->ExceptionCheck (env) || !object) { GST_ERROR ("Failed to call Java method"); (*env)->ExceptionClear (env); From 7562cc2e26dee7db146002d91c5933b6a35095e7 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 06/82] Add a deinit function and remove jclass references in case of error --- .../gst-android-graphics-imageformat.c | 26 ++++++- .../gst-android-graphics-imageformat.h | 1 + .../gst-android-graphics-surfacetexture.c | 26 ++++++- .../gst-android-graphics-surfacetexture.h | 1 + .../gst-android-hardware-camera.c | 76 +++++++++++++++---- .../gst-android-hardware-camera.h | 1 + sys/androidcamera/gst-androidmedia.c | 12 ++- 7 files changed, 121 insertions(+), 22 deletions(-) diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c index a79f6f0b86..d0766b4da7 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.c +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -38,7 +38,7 @@ static struct jint UNKNOWN; jint YUY2; jint YV12; -} android_graphics_imageformat; +} android_graphics_imageformat = {0}; gint ImageFormat_JPEG; gint ImageFormat_NV16; @@ -48,8 +48,8 @@ gint ImageFormat_UNKNOWN; gint ImageFormat_YUY2; gint ImageFormat_YV12; -gboolean -gst_android_graphics_imageformat_init () +static gboolean +_init_classes () { JNIEnv *env = gst_dvm_get_env (); @@ -77,6 +77,26 @@ gst_android_graphics_imageformat_init () return TRUE; } +gboolean +gst_android_graphics_imageformat_init () +{ + if (!_init_classes ()) { + gst_android_graphics_imageformat_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_graphics_imageformat_deinit () +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_graphics_imageformat.klass) + (*env)->DeleteGlobalRef (env, android_graphics_imageformat.klass); + android_graphics_imageformat.klass = NULL; +} /* android.graphics.ImageFormat */ gint diff --git a/sys/androidcamera/gst-android-graphics-imageformat.h b/sys/androidcamera/gst-android-graphics-imageformat.h index 590e828620..84b48f8af6 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.h +++ b/sys/androidcamera/gst-android-graphics-imageformat.h @@ -37,6 +37,7 @@ extern gint ImageFormat_YUY2; extern gint ImageFormat_YV12; gboolean gst_android_graphics_imageformat_init (void); +void gst_android_graphics_imageformat_deinit (void); gint gst_ag_imageformat_get_bits_per_pixel (gint format); diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index 432f12034a..27ef352771 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -32,10 +32,10 @@ static struct jclass klass; jmethodID constructor; jmethodID release; -} android_graphics_surfacetexture; +} android_graphics_surfacetexture = {0}; -gboolean -gst_android_graphics_surfacetexture_init () +static gboolean +_init_classes () { JNIEnv *env = gst_dvm_get_env (); @@ -49,6 +49,26 @@ gst_android_graphics_surfacetexture_init () return TRUE; } +gboolean +gst_android_graphics_surfacetexture_init () +{ + if (!_init_classes ()) { + gst_android_graphics_surfacetexture_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_graphics_surfacetexture_deinit () +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_graphics_surfacetexture.klass) + (*env)->DeleteGlobalRef (env, android_graphics_surfacetexture.klass); + android_graphics_surfacetexture.klass = NULL; +} /* android.graphics.SurfaceTexture */ GstAGSurfaceTexture * diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.h b/sys/androidcamera/gst-android-graphics-surfacetexture.h index 4d77e874b2..7938e3e8fe 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.h +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.h @@ -36,6 +36,7 @@ struct _GstAGSurfaceTexture { gboolean gst_android_graphics_surfacetexture_init (void); +void gst_android_graphics_surfacetexture_deinit (void); /* android.graphics.SurfaceTexture */ GstAGSurfaceTexture *gst_ag_surfacetexture_new (gint texture_id); diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 170fafbc81..963c72e871 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -46,7 +46,7 @@ static struct jmethodID stopPreview; jmethodID stopSmoothZoom; jmethodID unlock; -} android_hardware_camera; +} android_hardware_camera = {0}; static struct { @@ -56,7 +56,7 @@ static struct jfieldID orientation; jint CAMERA_FACING_BACK; jint CAMERA_FACING_FRONT; -} android_hardware_camera_camerainfo; +} android_hardware_camera_camerainfo = {0}; gint CameraInfo_CAMERA_FACING_BACK; gint CameraInfo_CAMERA_FACING_FRONT; @@ -65,7 +65,7 @@ static struct jclass klass; jfieldID width; jfieldID height; -} android_hardware_camera_size; +} android_hardware_camera_size = {0}; /* TODO: Add other parameters */ static struct @@ -82,32 +82,32 @@ static struct jmethodID setPreviewFpsRange; jmethodID setPreviewSize; jmethodID unflatten; -} android_hardware_camera_parameters; +} android_hardware_camera_parameters = {0}; static struct { jclass klass; jmethodID iterator; -} java_util_list; +} java_util_list = {0}; static struct { jclass klass; jmethodID hasNext; jmethodID next; -} java_util_iterator; +} java_util_iterator = {0}; static struct { jclass klass; jmethodID intValue; -} java_lang_integer; +} java_lang_integer = {0}; static struct { jclass klass; jmethodID constructor; -} com_gstreamer_gstahccallback; +} com_gstreamer_gstahccallback = {0}; static void gst_ah_camera_on_preview_frame (JNIEnv * env, jclass klass, jbyteArray data, @@ -134,16 +134,11 @@ static JNINativeMethod native_methods[] = { (void *) gst_ah_camera_on_error} }; -gboolean -gst_android_hardware_camera_init () +static gboolean +_init_classes () { JNIEnv *env = gst_dvm_get_env (); - if (!gst_android_graphics_surfacetexture_init ()) - return FALSE; - if (!gst_android_graphics_imageformat_init ()) - return FALSE; - /* android.hardware.Camera */ GST_DVM_GET_CLASS (android_hardware_camera, "android/hardware/Camera"); GST_DVM_GET_METHOD (android_hardware_camera, addCallbackBuffer, "([B)V"); @@ -248,6 +243,57 @@ gst_android_hardware_camera_init () } +gboolean +gst_android_hardware_camera_init () +{ + if (!_init_classes ()) { + gst_android_hardware_camera_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_hardware_camera_deinit () +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_hardware_camera.klass) + (*env)->DeleteGlobalRef (env, android_hardware_camera.klass); + android_hardware_camera.klass = NULL; + + if (android_hardware_camera_camerainfo.klass) + (*env)->DeleteGlobalRef (env, android_hardware_camera_camerainfo.klass); + android_hardware_camera_camerainfo.klass = NULL; + + if (android_hardware_camera_size.klass) + (*env)->DeleteGlobalRef (env, android_hardware_camera_size.klass); + android_hardware_camera_size.klass = NULL; + + if (android_hardware_camera_parameters.klass) + (*env)->DeleteGlobalRef (env, android_hardware_camera_parameters.klass); + android_hardware_camera_parameters.klass = NULL; + + if (java_util_list.klass) + (*env)->DeleteGlobalRef (env, java_util_list.klass); + java_util_list.klass = NULL; + + if (java_util_iterator.klass) + (*env)->DeleteGlobalRef (env, java_util_iterator.klass); + java_util_iterator.klass = NULL; + + if (java_lang_integer.klass) + (*env)->DeleteGlobalRef (env, java_lang_integer.klass); + java_lang_integer.klass = NULL; + + if (com_gstreamer_gstahccallback.klass) { + (*env)->UnregisterNatives (env, com_gstreamer_gstahccallback.klass); + (*env)->DeleteGlobalRef (env, com_gstreamer_gstahccallback.klass); + } + com_gstreamer_gstahccallback.klass = NULL; +} + /* android.hardware.Camera */ void gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer) diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index a83811880b..2ff03f8d2e 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -66,6 +66,7 @@ typedef void (*GstAHCErrorCallback) (gint error, gpointer user_data); typedef void (*GstAHCPreviewCallback) (jbyteArray data, gpointer user_data); gboolean gst_android_hardware_camera_init (void); +void gst_android_hardware_camera_deinit (void); /* android.hardware.Camera */ void gst_ah_camera_add_callback_buffer (GstAHCamera *self, diff --git a/sys/androidcamera/gst-androidmedia.c b/sys/androidcamera/gst-androidmedia.c index ee42f2b838..ad44149a38 100644 --- a/sys/androidcamera/gst-androidmedia.c +++ b/sys/androidcamera/gst-androidmedia.c @@ -38,9 +38,19 @@ plugin_init (GstPlugin * plugin) if (!gst_dvm_init ()) return FALSE; - if (!gst_android_hardware_camera_init ()) + if (!gst_android_graphics_surfacetexture_init ()) return FALSE; + if (!gst_android_graphics_imageformat_init ()) { + gst_android_graphics_surfacetexture_deinit (); + return FALSE; + } + if (!gst_android_hardware_camera_init ()) { + gst_android_graphics_surfacetexture_deinit (); + gst_android_graphics_imageformat_deinit (); + return FALSE; + } + return gst_element_register (plugin, "ahcsrc", GST_RANK_NONE, GST_TYPE_AHC_SRC); } From 666eda11d6d5e357236ef8ab2053e3efaefe7e54 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 07/82] Use YV12 as the default format --- sys/androidcamera/gstahcsrc.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 331b33a628..a9c83ecfe6 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -207,15 +207,15 @@ gst_ahc_src_open (GstAHCSrc * self) GST_WARNING_OBJECT (self, "Params : %s", gst_ahc_parameters_flatten (params)); - gst_ahc_parameters_set_preview_size (params, 640, 480); - gst_ahc_parameters_set_preview_format (params, ImageFormat_NV21); + gst_ahc_parameters_set_preview_size (params, 1280, 720); + gst_ahc_parameters_set_preview_format (params, ImageFormat_YV12); GST_WARNING_OBJECT (self, "Setting new params (%d) : %s", gst_ah_camera_set_parameters (self->camera, params), gst_ahc_parameters_flatten (params)); size = gst_ahc_parameters_get_preview_size (params); self->caps = gst_caps_new_simple ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '2', '1'), + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'V', '1', '2'), "width", G_TYPE_INT, size->width, "height", G_TYPE_INT, size->height, "framerate", GST_TYPE_FRACTION, 30, 1, NULL); From af47c1ebdc182c17b88c59cf393aea3bcd280bdb Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 08/82] Remove open failure test code and debug log --- sys/androidcamera/gstahcsrc.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index a9c83ecfe6..9afc6ca19b 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -282,8 +282,6 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstAHCSrc *self = GST_AHC_SRC (element); - GST_WARNING_OBJECT (self, "Changing state %d", transition); - switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: { @@ -292,7 +290,7 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) GST_WARNING_OBJECT (self, "Found %d cameras on the system", num_cams); - for (i = 0; i <= num_cams; i++) { + for (i = 0; i < num_cams; i++) { GstAHCCameraInfo info; if (gst_ah_camera_get_camera_info (i, &info)) { GST_WARNING_OBJECT (self, "Camera info for %d", i); From 4cbfe6fa134cc9d59e845c097d1d00ee131bed1d Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 09/82] Use the buffer's free_func to map byteArray data without making a copy --- sys/androidcamera/gstahcsrc.c | 40 +++++++++++++++++++++++++++++------ 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 9afc6ca19b..ec86ecf0ff 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -385,11 +385,33 @@ gst_ahc_src_unlock_stop (GstBaseSrc * bsrc) return TRUE; } +typedef struct { + GstAHCSrc *self; + jbyteArray array; + jbyte *data; +} FreeFuncBuffer; + +static void +gst_ahc_src_buffer_free_func (gpointer priv) +{ + FreeFuncBuffer *data = (FreeFuncBuffer *) priv; + GstAHCSrc *self = data->self; + JNIEnv *env = gst_dvm_get_env (); + + (*env)->ReleaseByteArrayElements(env, data->array, data->data, JNI_ABORT); + if (self->camera) + gst_ah_camera_add_callback_buffer (self->camera, data->array); + (*env)->DeleteGlobalRef (env, data->array); + + g_slice_free (FreeFuncBuffer, data); +} + static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) { GstAHCSrc *self = GST_AHC_SRC (src); JNIEnv *env = gst_dvm_get_env (); + FreeFuncBuffer *user_data; jbyteArray data = NULL; while (data == NULL) { @@ -398,13 +420,19 @@ gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) return GST_FLOW_WRONG_STATE; } - *buffer = gst_buffer_new_and_alloc (self->buffer_size); - (*env)->GetByteArrayRegion (env, data, 0, self->buffer_size, - (jbyte *) GST_BUFFER_DATA (*buffer)); - gst_buffer_set_caps (*buffer, self->caps); + //GST_WARNING_OBJECT (self, "Received data buffer %p", data); - gst_ah_camera_add_callback_buffer (self->camera, data); - (*env)->DeleteGlobalRef (env, data); + user_data = g_slice_new0 (FreeFuncBuffer); + user_data->self = self; + user_data->array = data; + user_data->data = (*env)->GetByteArrayElements (env, data, NULL); + + *buffer = gst_buffer_new (); + GST_BUFFER_DATA (*buffer) = (guint8 *) user_data->data; + GST_BUFFER_SIZE (*buffer) = self->buffer_size; + GST_BUFFER_MALLOCDATA (*buffer) = (gpointer) user_data; + GST_BUFFER_FREE_FUNC (*buffer) = gst_ahc_src_buffer_free_func; + gst_buffer_set_caps (*buffer, self->caps); return GST_FLOW_OK; } From 3c78395e317534d5a8d3a4fede97692a35ef33e6 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 10/82] Use GstDataQueue instead of GAsyncQueue for storing buffers --- sys/androidcamera/gstahcsrc.c | 117 ++++++++++++++++++++-------------- sys/androidcamera/gstahcsrc.h | 5 +- 2 files changed, 73 insertions(+), 49 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index ec86ecf0ff..ba66bef239 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -102,6 +102,13 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstpushsrc_class->create = gst_ahc_src_create; } +static gboolean +_data_queue_check_full (GstDataQueue *queue, guint visible, + guint bytes, guint64 time, gpointer checkdata) +{ + return FALSE; +} + static void gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) { @@ -112,9 +119,8 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) self->camera = NULL; self->texture = gst_ag_surfacetexture_new (0); self->data = NULL; - self->queue = g_async_queue_new (); + self->queue = gst_data_queue_new (_data_queue_check_full, NULL); self->caps = NULL; - self->flushing = FALSE; } static void @@ -130,6 +136,10 @@ gst_ahc_src_dispose (GObject * object) gst_ag_surfacetexture_release (self->texture); self->texture = NULL; + if (self->queue) + g_object_unref (self->queue); + self->queue = NULL; + G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -169,14 +179,63 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } } +typedef struct { + GstAHCSrc *self; + jbyteArray array; + jbyte *data; +} FreeFuncBuffer; + +static void +gst_ahc_src_buffer_free_func (gpointer priv) +{ + FreeFuncBuffer *data = (FreeFuncBuffer *) priv; + GstAHCSrc *self = data->self; + JNIEnv *env = gst_dvm_get_env (); + + (*env)->ReleaseByteArrayElements(env, data->array, data->data, JNI_ABORT); + if (self->camera) + gst_ah_camera_add_callback_buffer (self->camera, data->array); + (*env)->DeleteGlobalRef (env, data->array); + + g_slice_free (FreeFuncBuffer, data); +} + +static void +_data_queue_item_free (GstDataQueueItem *item) +{ + g_slice_free (GstDataQueueItem, item); +} + static void gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) { GstAHCSrc *self = GST_AHC_SRC (user_data); JNIEnv *env = gst_dvm_get_env (); + GstBuffer *buffer; + GstDataQueueItem *item = g_slice_new0 (GstDataQueueItem); + FreeFuncBuffer *malloc_data = g_slice_new0 (FreeFuncBuffer); - //GST_WARNING_OBJECT (self, "Received data buffer %p", data); - g_async_queue_push (self->queue, (*env)->NewGlobalRef (env, data)); + GST_WARNING_OBJECT (self, "Received data buffer %p", data); + malloc_data->self = self; + malloc_data->array = (*env)->NewGlobalRef (env, data); + malloc_data->data = (*env)->GetByteArrayElements (env, data, NULL); + + buffer = gst_buffer_new (); + GST_BUFFER_DATA (buffer) = (guint8 *) malloc_data->data; + GST_BUFFER_SIZE (buffer) = self->buffer_size; + GST_BUFFER_MALLOCDATA (buffer) = (gpointer) malloc_data; + GST_BUFFER_FREE_FUNC (buffer) = gst_ahc_src_buffer_free_func; + GST_BUFFER_DURATION (buffer) = (1.0 / 30.0) * GST_SECOND; + + gst_buffer_set_caps (buffer, self->caps); + + item->object = GST_MINI_OBJECT (buffer); + item->size = GST_BUFFER_SIZE (buffer); + item->duration = GST_BUFFER_DURATION (buffer); + item->visible = TRUE; + item->destroy = (GDestroyNotify) _data_queue_item_free; + + gst_data_queue_push (self->queue, item); } static void @@ -185,7 +244,6 @@ gst_ahc_src_on_error (int error, gpointer user_data) GstAHCSrc *self = GST_AHC_SRC (user_data); GST_WARNING_OBJECT (self, "Received error code : %d", error); - } static gboolean @@ -369,7 +427,7 @@ gst_ahc_src_unlock (GstBaseSrc * bsrc) GstAHCSrc *self = GST_AHC_SRC (bsrc); GST_WARNING_OBJECT (self, "Unlocking create"); - self->flushing = TRUE; + gst_data_queue_set_flushing (self->queue, TRUE); return TRUE; } @@ -380,59 +438,24 @@ gst_ahc_src_unlock_stop (GstBaseSrc * bsrc) GstAHCSrc *self = GST_AHC_SRC (bsrc); GST_WARNING_OBJECT (self, "Stopping unlock"); - self->flushing = FALSE; + gst_data_queue_set_flushing (self->queue, FALSE); return TRUE; } -typedef struct { - GstAHCSrc *self; - jbyteArray array; - jbyte *data; -} FreeFuncBuffer; - -static void -gst_ahc_src_buffer_free_func (gpointer priv) -{ - FreeFuncBuffer *data = (FreeFuncBuffer *) priv; - GstAHCSrc *self = data->self; - JNIEnv *env = gst_dvm_get_env (); - - (*env)->ReleaseByteArrayElements(env, data->array, data->data, JNI_ABORT); - if (self->camera) - gst_ah_camera_add_callback_buffer (self->camera, data->array); - (*env)->DeleteGlobalRef (env, data->array); - - g_slice_free (FreeFuncBuffer, data); -} - static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) { GstAHCSrc *self = GST_AHC_SRC (src); - JNIEnv *env = gst_dvm_get_env (); - FreeFuncBuffer *user_data; - jbyteArray data = NULL; + GstDataQueueItem *item; - while (data == NULL) { - data = g_async_queue_timeout_pop (self->queue, 100000); - if (data == NULL && self->flushing) - return GST_FLOW_WRONG_STATE; - } + if (!gst_data_queue_pop (self->queue, &item)) + return GST_FLOW_WRONG_STATE; //GST_WARNING_OBJECT (self, "Received data buffer %p", data); - user_data = g_slice_new0 (FreeFuncBuffer); - user_data->self = self; - user_data->array = data; - user_data->data = (*env)->GetByteArrayElements (env, data, NULL); - - *buffer = gst_buffer_new (); - GST_BUFFER_DATA (*buffer) = (guint8 *) user_data->data; - GST_BUFFER_SIZE (*buffer) = self->buffer_size; - GST_BUFFER_MALLOCDATA (*buffer) = (gpointer) user_data; - GST_BUFFER_FREE_FUNC (*buffer) = gst_ahc_src_buffer_free_func; - gst_buffer_set_caps (*buffer, self->caps); + *buffer = GST_BUFFER (item->object); + _data_queue_item_free (item); return GST_FLOW_OK; } diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index 664b058897..71956eecfe 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -24,6 +24,8 @@ #include #include +#include + #include "gst-android-hardware-camera.h" G_BEGIN_DECLS @@ -51,9 +53,8 @@ struct _GstAHCSrc GstAGSurfaceTexture *texture; GstCaps *caps; GList *data; - GAsyncQueue *queue; + GstDataQueue *queue; gint buffer_size; - gboolean flushing; }; struct _GstAHCSrcClass From fff14b255cef63db8f8d1b88e6751c51c8fc8553 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 11/82] Make the number of callback buffers configurable, and delete their local ref --- sys/androidcamera/gstahcsrc.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index ba66bef239..5745bd543e 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -43,6 +43,8 @@ static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); +#define NUM_CALLBACK_BUFFERS 5 + #define GST_AHC_SRC_CAPS_STR \ GST_VIDEO_CAPS_YUV (" { YV12 , YUY2 , NV21 , NV16 }") ";" \ GST_VIDEO_CAPS_RGB_16 @@ -262,6 +264,7 @@ gst_ahc_src_open (GstAHCSrc * self) GST_WARNING_OBJECT (self, "Opened camera"); if (params) { GstAHCSize *size; + int i; GST_WARNING_OBJECT (self, "Params : %s", gst_ahc_parameters_flatten (params)); @@ -286,12 +289,13 @@ gst_ahc_src_open (GstAHCSrc * self) self); gst_ah_camera_set_preview_callback_with_buffer (self->camera, gst_ahc_src_on_preview_frame, self); - gst_ah_camera_add_callback_buffer (self->camera, - (*env)->NewByteArray (env, self->buffer_size)); - gst_ah_camera_add_callback_buffer (self->camera, - (*env)->NewByteArray (env, self->buffer_size)); - gst_ah_camera_add_callback_buffer (self->camera, - (*env)->NewByteArray (env, self->buffer_size)); + + for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { + jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); + + gst_ah_camera_add_callback_buffer (self->camera, array); + (*env)->DeleteLocalRef (env, array); + } { GList *list, *i; From 7b8dbd32db8baca19163e2ff783710ce2b8af421 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 12/82] Calculate timestamp at reception of the buffer, not when pushing it out --- sys/androidcamera/gstahcsrc.c | 27 +++++++++++++++++++++------ sys/androidcamera/gstahcsrc.h | 1 + 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 5745bd543e..bf5adab7ba 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -116,7 +116,7 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) { gst_base_src_set_live (GST_BASE_SRC (self), TRUE); gst_base_src_set_format (GST_BASE_SRC (self), GST_FORMAT_TIME); - gst_base_src_set_do_timestamp (GST_BASE_SRC (self), TRUE); + gst_base_src_set_do_timestamp (GST_BASE_SRC (self), FALSE); self->camera = NULL; self->texture = gst_ag_surfacetexture_new (0); @@ -216,8 +216,9 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GstBuffer *buffer; GstDataQueueItem *item = g_slice_new0 (GstDataQueueItem); FreeFuncBuffer *malloc_data = g_slice_new0 (FreeFuncBuffer); + GstClock *clock; - GST_WARNING_OBJECT (self, "Received data buffer %p", data); + //GST_WARNING_OBJECT (self, "Received data buffer %p", data); malloc_data->self = self; malloc_data->array = (*env)->NewGlobalRef (env, data); malloc_data->data = (*env)->GetByteArrayElements (env, data, NULL); @@ -227,7 +228,21 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GST_BUFFER_SIZE (buffer) = self->buffer_size; GST_BUFFER_MALLOCDATA (buffer) = (gpointer) malloc_data; GST_BUFFER_FREE_FUNC (buffer) = gst_ahc_src_buffer_free_func; - GST_BUFFER_DURATION (buffer) = (1.0 / 30.0) * GST_SECOND; + GST_BUFFER_DURATION (buffer) = 0; + GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE; + if ((clock = GST_ELEMENT_CLOCK (self))) { + GstClockTime base_time = GST_ELEMENT_CAST (self)->base_time; + GstClockTime current_ts; + + gst_object_ref (clock); + current_ts = gst_clock_get_time (clock) - base_time; + if (GST_CLOCK_TIME_IS_VALID (self->previous_ts)) { + GST_BUFFER_TIMESTAMP (buffer) = self->previous_ts; + GST_BUFFER_DURATION (buffer) = current_ts - self->previous_ts; + } + self->previous_ts = current_ts; + gst_object_unref (clock); + } gst_buffer_set_caps (buffer, self->caps); @@ -287,8 +302,6 @@ gst_ahc_src_open (GstAHCSrc * self) gst_ah_camera_set_preview_texture (self->camera, self->texture); gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, self); - gst_ah_camera_set_preview_callback_with_buffer (self->camera, - gst_ahc_src_on_preview_frame, self); for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); @@ -404,9 +417,11 @@ gst_ahc_src_start (GstBaseSrc * bsrc) GST_WARNING_OBJECT (self, "Starting preview"); if (self->camera) { gboolean ret = gst_ah_camera_start_preview (self->camera); - if (ret) + if (ret) { + self->previous_ts = GST_CLOCK_TIME_NONE; gst_ah_camera_set_preview_callback_with_buffer (self->camera, gst_ahc_src_on_preview_frame, self); + } return ret; } else { return FALSE; diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index 71956eecfe..c28f0b640d 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -55,6 +55,7 @@ struct _GstAHCSrc GList *data; GstDataQueue *queue; gint buffer_size; + GstClockTime previous_ts; }; struct _GstAHCSrcClass From 65a6014f26f4350c318417c023091d495e51edfa Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 13/82] Add a GST_DVM_CALL macro to ease function calling with exception check --- .../gst-android-graphics-imageformat.c | 10 +- .../gst-android-graphics-surfacetexture.c | 3 +- .../gst-android-hardware-camera.c | 309 +++++------------- sys/androidcamera/gst-dvm.h | 19 ++ 4 files changed, 107 insertions(+), 234 deletions(-) diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c index d0766b4da7..26f649a191 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.c +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -105,14 +105,8 @@ gst_ag_imageformat_get_bits_per_pixel (gint format) JNIEnv *env = gst_dvm_get_env (); jint bpp = 0; - bpp = (*env)->CallStaticIntMethod (env, - android_graphics_imageformat.klass, - android_graphics_imageformat.getBitsPerPixel, format); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return -1; - } + bpp = GST_DVM_STATIC_CALL(return -1, Int, + android_graphics_imageformat, getBitsPerPixel, format); return bpp; } diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index 27ef352771..3182a6516f 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -105,8 +105,7 @@ gst_ag_surfacetexture_release (GstAGSurfaceTexture * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_graphics_surfacetexture.release); + GST_DVM_CALL(, self->object, Void, android_graphics_surfacetexture, release); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAGSurfaceTexture, self); diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 963c72e871..077aff2ef7 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -295,14 +295,19 @@ gst_android_hardware_camera_deinit () } /* android.hardware.Camera */ +#define AHC_CALL(error_statement, type, method, ...) \ + GST_DVM_CALL (error_statement, self->object, type, android_hardware_camera, \ + method, ## __VA_ARGS__); +#define AHC_STATIC_CALL(error_statement, type, method, ...) \ + GST_DVM_STATIC_CALL (error_statement, type, android_hardware_camera, \ + method, ## __VA_ARGS__); + void gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer) { JNIEnv *env = gst_dvm_get_env (); - /* TODO: use a java.nio.ByteBuffer if possible */ - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.addCallbackBuffer, buffer); + AHC_CALL (, Void, addCallbackBuffer, buffer); } gboolean @@ -310,7 +315,7 @@ gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) { JNIEnv *env = gst_dvm_get_env (); jobject jcamera_info = NULL; - gboolean ret = TRUE; + gboolean ret = FALSE; jcamera_info = (*env)->NewObject (env, android_hardware_camera_camerainfo.klass, @@ -318,25 +323,16 @@ gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) if (!jcamera_info) { GST_ERROR ("Failed to call Java method"); (*env)->ExceptionClear (env); - ret = FALSE; goto done; } - (*env)->CallStaticVoidMethod (env, android_hardware_camera.klass, - android_hardware_camera.getCameraInfo, camera_id, jcamera_info); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - ret = FALSE; - goto done; - } + AHC_STATIC_CALL (goto done, Void, getCameraInfo, camera_id, jcamera_info); camera_info->facing = (*env)->GetIntField (env, jcamera_info, android_hardware_camera_camerainfo.facing); if ((*env)->ExceptionCheck (env)) { GST_ERROR ("Failed to get CameraInfo.facing field"); (*env)->ExceptionClear (env); - ret = FALSE; goto done; } @@ -345,10 +341,10 @@ gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) if ((*env)->ExceptionCheck (env)) { GST_ERROR ("Failed to get CameraInfo.orientation field"); (*env)->ExceptionClear (env); - ret = FALSE; goto done; } + ret = TRUE; done: if (jcamera_info) (*env)->DeleteLocalRef (env, jcamera_info); @@ -362,13 +358,7 @@ gst_ah_camera_get_number_of_cameras () JNIEnv *env = gst_dvm_get_env (); gint num_cameras; - num_cameras = (*env)->CallStaticIntMethod (env, android_hardware_camera.klass, - android_hardware_camera.getNumberOfCameras); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return -1; - } + num_cameras = AHC_STATIC_CALL (return -1, Int, getNumberOfCameras); return num_cameras; } @@ -380,23 +370,17 @@ gst_ah_camera_get_parameters (GstAHCamera * self) jobject object = NULL; GstAHCParameters *params = NULL; - object = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera.getParameters); - if ((*env)->ExceptionCheck (env) || !object) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return NULL; - } + object = AHC_CALL (return NULL, Object, getParameters); params = g_slice_new0 (GstAHCParameters); params->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); if (!params->object) { GST_ERROR ("Failed to create global reference"); (*env)->ExceptionClear (env); g_slice_free (GstAHCParameters, params); - params = NULL; + return NULL; } - (*env)->DeleteLocalRef (env, object); return params; } @@ -406,12 +390,7 @@ gst_ah_camera_lock (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, android_hardware_camera.lock); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, lock); return TRUE; } @@ -423,28 +402,21 @@ gst_ah_camera_open (gint camera_id) jobject object = NULL; GstAHCamera *camera = NULL; - object = (*env)->CallStaticObjectMethod (env, android_hardware_camera.klass, - android_hardware_camera.open, camera_id); - if ((*env)->ExceptionCheck (env) || !object) { - /* TODO: return a GError ? */ - //jthrowable e = (*env)->ExceptionOccurred(env); - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionDescribe (env); - (*env)->ExceptionClear (env); - return NULL; - } + object = AHC_STATIC_CALL (goto done, Object, open, camera_id); camera = g_slice_new0 (GstAHCamera); camera->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); if (!camera->object) { GST_ERROR ("Failed to create global reference"); (*env)->ExceptionClear (env); g_slice_free (GstAHCamera, camera); - camera = NULL; + goto done; } - (*env)->DeleteLocalRef (env, object); return camera; +done: + return NULL; } gboolean @@ -452,12 +424,7 @@ gst_ah_camera_reconnect (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, android_hardware_camera.reconnect); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, reconnect); return TRUE; } @@ -467,7 +434,7 @@ gst_ah_camera_release (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, android_hardware_camera.release); + AHC_CALL (, Void, release); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAHCamera, self); @@ -478,13 +445,7 @@ gst_ah_camera_set_parameters (GstAHCamera * self, GstAHCParameters * params) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.setParameters, params->object); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, setParameters, params->object); return TRUE; } @@ -495,7 +456,7 @@ gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, { JNIEnv *env = gst_dvm_get_env (); jobject object; - gboolean ret = TRUE; + gboolean ret = FALSE; object = (*env)->NewObject (env, com_gstreamer_gstahccallback.klass, @@ -504,18 +465,12 @@ gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, if (!object) { GST_ERROR ("Failed to create callback object"); (*env)->ExceptionClear (env); - ret = FALSE; - goto done; - } - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.setErrorCallback, object); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - ret = FALSE; goto done; } + AHC_CALL (goto done, Void, setErrorCallback, object); + + ret = TRUE; done: if (object) (*env)->DeleteLocalRef (env, object); @@ -529,7 +484,7 @@ gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, { JNIEnv *env = gst_dvm_get_env (); jobject object; - gboolean ret = TRUE; + gboolean ret = FALSE; object = (*env)->NewObject (env, com_gstreamer_gstahccallback.klass, @@ -538,18 +493,12 @@ gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, if (!object) { GST_ERROR ("Failed to create callback object"); (*env)->ExceptionClear (env); - ret = FALSE; - goto done; - } - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.setPreviewCallbackWithBuffer, object); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - ret = FALSE; goto done; } + AHC_CALL (goto done, Void, setPreviewCallbackWithBuffer, object); + + ret = TRUE; done: if (object) (*env)->DeleteLocalRef (env, object); @@ -563,8 +512,7 @@ gst_ah_camera_set_preview_texture (GstAHCamera * self, { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.setPreviewTexture, surfaceTexture->object); + AHC_CALL (, Void, setPreviewTexture, surfaceTexture->object); } gboolean @@ -572,13 +520,7 @@ gst_ah_camera_start_preview (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.startPreview); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, startPreview); return TRUE; } @@ -588,13 +530,7 @@ gst_ah_camera_start_smooth_zoom (GstAHCamera * self, gint value) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.startSmoothZoom, value); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, startSmoothZoom, value); return TRUE; } @@ -604,13 +540,7 @@ gst_ah_camera_stop_preview (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.stopPreview); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, stopPreview); return TRUE; } @@ -620,13 +550,7 @@ gst_ah_camera_stop_smooth_zoom (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera.stopSmoothZoom); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, stopSmoothZoom); return TRUE; } @@ -636,16 +560,14 @@ gst_ah_camera_unlock (GstAHCamera * self) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, android_hardware_camera.unlock); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHC_CALL (return FALSE, Void, unlock); return TRUE; } +#undef AHC_CALL +#undef AHC_STATIC_CALL + /* android.hardware.Camera.Size */ GstAHCSize * gst_ahc_size_new (gint width, gint height) @@ -664,8 +586,39 @@ gst_ahc_size_free (GstAHCSize * self) g_slice_free (GstAHCSize, self); } +/* java.util.List */ +static jobject +java_util_list_iterator (JNIEnv * env, jobject obj) +{ + return (*env)->CallObjectMethod (env, obj, java_util_list.iterator); +} + +static jobject +java_util_iterator_next (JNIEnv * env, jobject obj) +{ + return (*env)->CallObjectMethod (env, obj, java_util_iterator.next); +} + +static jboolean +java_util_iterator_has_next (JNIEnv * env, jobject obj) +{ + return (*env)->CallBooleanMethod (env, obj, java_util_iterator.hasNext); +} + +static jint +java_lang_integer_int_value (JNIEnv * env, jobject obj) +{ + return (*env)->CallIntMethod (env, obj, java_lang_integer.intValue); +} /* android.hardware.Camera.Parameters */ +#define AHCP_CALL(error_statement, type, method, ...) \ + GST_DVM_CALL (error_statement, self->object, type, \ + android_hardware_camera_parameters, method, ## __VA_ARGS__); +#define AHCP_STATIC_CALL(error_statement, type, method, ...) \ + GST_DVM_STATIC_CALL (error_statement, type, \ + android_hardware_camera_parameters, method, ## __VA_ARGS__); + gchar * gst_ahc_parameters_flatten (GstAHCParameters * self) { @@ -674,14 +627,7 @@ gst_ahc_parameters_flatten (GstAHCParameters * self) const gchar *v = NULL; gchar *ret = NULL; - v_str = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera_parameters.flatten); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - goto done; - } - + v_str = AHCP_CALL (goto done, Object, flatten); v = (*env)->GetStringUTFChars (env, v_str, NULL); if (!v) { GST_ERROR ("Failed to convert string to UTF8"); @@ -705,13 +651,7 @@ gst_ahc_parameters_get_preview_format (GstAHCParameters * self) JNIEnv *env = gst_dvm_get_env (); gint format; - format = (*env)->CallIntMethod (env, self->object, - android_hardware_camera_parameters.getPreviewFormat); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return 0; - } + format = AHCP_CALL (return 0, Int, getPreviewFormat); return format; } @@ -721,7 +661,7 @@ gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, gint * min, gint * max) { JNIEnv *env = gst_dvm_get_env (); - gboolean ret = TRUE; + gboolean ret = FALSE; jintArray range = NULL; jint *fps = NULL; @@ -729,23 +669,15 @@ gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, if (!fps) { (*env)->ExceptionClear (env); GST_ERROR ("Failed to create array"); - ret = FALSE; goto done; } - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera_parameters.getPreviewFpsRange, range); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return 0; - } + AHCP_CALL (goto done, Void, getPreviewFpsRange, range); fps = (*env)->GetIntArrayElements (env, range, NULL); if ((*env)->ExceptionCheck (env) || !fps) { (*env)->ExceptionClear (env); GST_ERROR ("Failed to get array elements"); - ret = FALSE; goto done; } if (min) @@ -753,6 +685,7 @@ gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, if (max) *max = fps[1]; + ret = TRUE; done: if (fps) (*env)->ReleaseIntArrayElements (env, range, fps, JNI_ABORT); @@ -769,13 +702,7 @@ gst_ahc_parameters_get_preview_size (GstAHCParameters * self) jobject jsize = NULL; GstAHCSize *size = NULL; - jsize = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera_parameters.getPreviewSize); - if ((*env)->ExceptionCheck (env) || !jsize) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - goto done; - } + jsize = AHCP_CALL (goto done, Object, getPreviewSize); size = g_slice_new0 (GstAHCSize); @@ -806,30 +733,6 @@ done: return size; } -static jobject -java_util_list_iterator (JNIEnv * env, jobject obj) -{ - return (*env)->CallObjectMethod (env, obj, java_util_list.iterator); -} - -static jobject -java_util_iterator_next (JNIEnv * env, jobject obj) -{ - return (*env)->CallObjectMethod (env, obj, java_util_iterator.next); -} - -static jboolean -java_util_iterator_has_next (JNIEnv * env, jobject obj) -{ - return (*env)->CallBooleanMethod (env, obj, java_util_iterator.hasNext); -} - -static jint -java_lang_integer_int_value (JNIEnv * env, jobject obj) -{ - return (*env)->CallIntMethod (env, obj, java_lang_integer.intValue); -} - GList * gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) { @@ -838,13 +741,7 @@ gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) jobject iterator = NULL; GList *ret = NULL; - list = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera_parameters.getSupportedPreviewFormats); - if ((*env)->ExceptionCheck (env) || !list) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return NULL; - } + list = AHCP_CALL (return NULL, Object, getSupportedPreviewFormats); iterator = java_util_list_iterator (env, list); if (iterator) { @@ -879,13 +776,7 @@ gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) jobject iterator = NULL; GList *ret = NULL; - list = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera_parameters.getSupportedPreviewFpsRange); - if ((*env)->ExceptionCheck (env) || !list) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return NULL; - } + list = AHCP_CALL (return NULL, Object, getSupportedPreviewFpsRange); iterator = java_util_list_iterator (env, list); if (iterator) { @@ -921,13 +812,7 @@ gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self) jobject iterator = NULL; GList *ret = NULL; - list = (*env)->CallObjectMethod (env, self->object, - android_hardware_camera_parameters.getSupportedPreviewSizes); - if ((*env)->ExceptionCheck (env) || !list) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return NULL; - } + list = AHCP_CALL (return NULL, Object, getSupportedPreviewSizes); iterator = java_util_list_iterator (env, list); if (iterator) { @@ -964,13 +849,7 @@ gst_ahc_parameters_set_preview_format (GstAHCParameters * self, gint format) { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera_parameters.setPreviewFormat, format); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHCP_CALL (return FALSE, Void, setPreviewFormat, format); return TRUE; } @@ -981,13 +860,7 @@ gst_ahc_parameters_set_preview_fps_range (GstAHCParameters * self, { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera_parameters.setPreviewFpsRange, min, max); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHCP_CALL (return FALSE, Void, setPreviewFpsRange, min, max); return TRUE; } @@ -998,13 +871,7 @@ gst_ahc_parameters_set_preview_size (GstAHCParameters * self, { JNIEnv *env = gst_dvm_get_env (); - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera_parameters.setPreviewSize, width, height); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - return FALSE; - } + AHCP_CALL (return FALSE, Void, setPreviewSize, width, height); return TRUE; } @@ -1020,13 +887,7 @@ gst_ahc_parameters_unflatten (GstAHCParameters * self, gchar * flattened) if (v_str == NULL) return FALSE; - (*env)->CallVoidMethod (env, self->object, - android_hardware_camera_parameters.unflatten, v_str); - if ((*env)->ExceptionCheck (env)) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - ret = FALSE; - } + AHCP_CALL (ret = FALSE, Void, unflatten, v_str); (*env)->DeleteLocalRef (env, v_str); diff --git a/sys/androidcamera/gst-dvm.h b/sys/androidcamera/gst-dvm.h index 4cef357a9e..e3f15fd087 100644 --- a/sys/androidcamera/gst-dvm.h +++ b/sys/androidcamera/gst-dvm.h @@ -96,6 +96,25 @@ } \ } +#define GST_DVM_STATIC_CALL(error_statement, type, k, method, ...) \ + (*env)->CallStatic##type##Method (env, k.klass, k.method, ## __VA_ARGS__); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to call Java method"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } + +#define GST_DVM_CALL(error_statement, obj, type, k, method, ...) \ + (*env)->Call##type##Method (env, obj, k.method, ## __VA_ARGS__); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to call Java method"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } + + JNIEnv *gst_dvm_get_env (void); gboolean gst_dvm_init (void); From 91219adaf23426fbf29282452ba9dc25b6697e82 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 14/82] Free the buffers and readd the arrays when the queue is cleared --- sys/androidcamera/gstahcsrc.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index bf5adab7ba..fbec0b1700 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -205,6 +205,7 @@ gst_ahc_src_buffer_free_func (gpointer priv) static void _data_queue_item_free (GstDataQueueItem *item) { + gst_buffer_unref (GST_BUFFER (item->object)); g_slice_free (GstDataQueueItem, item); } @@ -474,7 +475,7 @@ gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) //GST_WARNING_OBJECT (self, "Received data buffer %p", data); *buffer = GST_BUFFER (item->object); - _data_queue_item_free (item); + g_slice_free (GstDataQueueItem, item); return GST_FLOW_OK; } From e42e7317f929c35291f8fe73786360e46b486aff Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 15/82] Remove previous cruft and create androidcamera plugin --- sys/androidcamera/Makefile.am | 67 ++++--------------- ...gst-androidmedia.c => gst-androidcamera.c} | 16 ++--- 2 files changed, 20 insertions(+), 63 deletions(-) rename sys/androidcamera/{gst-androidmedia.c => gst-androidcamera.c} (86%) diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index fce98c7749..9d446e8e1b 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -1,25 +1,7 @@ -plugin_LTLIBRARIES = libgstandroidmedia.la +plugin_LTLIBRARIES = libgstandroidcamera.la -VIDEO_BASE_CLASSES_C = - video/video.c \ - video/gstvideodecoder.c \ - video/gstvideoencoder.c \ - video/gstvideoutils.c -VIDEO_BASE_CLASSES_H = - video/video.h \ - video/gstvideodecoder.h \ - video/gstvideoencoder.h \ - video/gstvideoutils.h - -libgstandroidmedia_la_SOURCES = \ - gst-androidmedia.c \ - gstamc.c \ - gstamcaudiodec.c \ - gstamcvideodec.c \ - video/video.c \ - video/gstvideodecoder.c \ - video/gstvideoencoder.c \ - video/gstvideoutils.c \ +libgstandroidcamera_la_SOURCES = \ + gst-androidcamera.c \ gst-dvm.c \ gst-android-hardware-camera.c \ gst-android-graphics-surfacetexture.c \ @@ -27,57 +9,36 @@ libgstandroidmedia_la_SOURCES = \ gstahcsrc.c noinst_HEADERS = \ - gstamc.h \ - gstamc-constants.h \ - gstamcaudiodec.h \ - gstamcvideodec.h \ - video/video.h \ - video/gstvideodecoder.h \ - video/gstvideoencoder.h \ - video/gstvideoutils.h \ gst-dvm.h \ gst-android-hardware-camera.h \ gst-android-graphics-surfacetexture.h \ gst-android-graphics-imageformat.h \ gstahcsrc.h -if !HAVE_GST_0_10_37 -libgstandroidmedia_la_SOURCES += $(VIDEO_BASE_CLASSES_C) -noinst_HEADERS += $(VIDEO_BASE_CLASSES_H) -endif - -libgstandroidmedia_la_CFLAGS = \ +libgstandroidcamera_la_CFLAGS = \ $(GST_PLUGINS_BASE_CFLAGS) \ $(GST_BASE_CFLAGS) \ $(GST_CFLAGS) \ - $(ORC_CFLAGS) \ - $(JAVA_CFLAGS) \ -I$(srcdir) -libgstandroidmedia_la_LIBADD = \ +libgstandroidcamera_la_LIBADD = \ $(GST_PLUGINS_BASE_LIBS) \ - -lgstaudio-@GST_MAJORMINOR@ \ - -lgstpbutils-@GST_MAJORMINOR@ \ - -lgstvideo-@GST_MAJORMINOR@ \ $(GST_BASE_LIBS) \ - $(GST_LIBS) \ - $(ORC_LIBS) -libgstandroidmedia_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -if !GST_PLUGIN_BUILD_STATIC -libgstandroidmedia_la_LIBTOOLFLAGS = --tag=disable-static -endif + $(GST_LIBS) +libgstandroidcamera_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) +libgstandroidcamera_la_LIBTOOLFLAGS = --tag=disable-static EXTRA_DIST = $(VIDEO_BASE_CLASSES_C) $(VIDEO_BASE_CLASSES_H) Android.mk: Makefile.am $(BUILT_SOURCES) androgenizer \ - -:PROJECT libgstandroidmedia -:SHARED libgstandroidmedia \ + -:PROJECT libgstandroidcamera -:SHARED libgstandroidcamera \ -:TAGS eng debug \ -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \ - -:SOURCES $(libgstandroidmedia_la_SOURCES) \ - $(nodist_libgstandroidmedia_la_SOURCES) \ - -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstandroidmedia_la_CFLAGS) \ - -:LDFLAGS $(libgstandroidmedia_la_LDFLAGS) \ - $(libgstandroidmedia_la_LIBADD) \ + -:SOURCES $(libgstandroidcamera_la_SOURCES) \ + $(libgstandroidcamera_la_SOURCES) \ + -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstandroidcamera_la_CFLAGS) \ + -:LDFLAGS $(libgstandroidcamera_la_LDFLAGS) \ + $(libgstandroidcamera_la_LIBADD) \ -ldl \ -:PASSTHROUGH LOCAL_ARM_MODE:=arm \ LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-@GST_MAJOR_MINOR@' \ diff --git a/sys/androidcamera/gst-androidmedia.c b/sys/androidcamera/gst-androidcamera.c similarity index 86% rename from sys/androidcamera/gst-androidmedia.c rename to sys/androidcamera/gst-androidcamera.c index ad44149a38..68c6a6be4b 100644 --- a/sys/androidcamera/gst-androidmedia.c +++ b/sys/androidcamera/gst-androidcamera.c @@ -1,6 +1,6 @@ /* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -24,7 +24,6 @@ #include -#include "gstamc.h" #include "gst-dvm.h" #include "gst-android-hardware-camera.h" #include "gstahcsrc.h" @@ -32,9 +31,6 @@ static gboolean plugin_init (GstPlugin * plugin) { - if (!gst_amc_init (plugin)) - return FALSE; - if (!gst_dvm_init ()) return FALSE; @@ -58,15 +54,15 @@ plugin_init (GstPlugin * plugin) #ifdef GST_PLUGIN_DEFINE2 GST_PLUGIN_DEFINE2 (GST_VERSION_MAJOR, GST_VERSION_MINOR, - androidmedia, - "Android Media plugin", + androidcamera, + "Android Camera plugin", plugin_init, PACKAGE_VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) #else GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, - "androidmedia", - "Android Media plugin", + "androidcamera", + "Android Camera plugin", plugin_init, PACKAGE_VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) #endif From d56f094ce6946c339bdfe53435c7f5c7cf4596af Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 17 Oct 2012 19:42:59 -0400 Subject: [PATCH 16/82] androidcamera: Fix compilation issues --- .../gst-android-graphics-imageformat.c | 11 ++++--- .../gst-android-graphics-surfacetexture.c | 11 ++++--- .../gst-android-hardware-camera.c | 33 ++++++++++++------- 3 files changed, 33 insertions(+), 22 deletions(-) diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c index 26f649a191..afa724ef06 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.c +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -38,7 +38,8 @@ static struct jint UNKNOWN; jint YUY2; jint YV12; -} android_graphics_imageformat = {0}; +} android_graphics_imageformat = { +0}; gint ImageFormat_JPEG; gint ImageFormat_NV16; @@ -49,7 +50,7 @@ gint ImageFormat_YUY2; gint ImageFormat_YV12; static gboolean -_init_classes () +_init_classes (void) { JNIEnv *env = gst_dvm_get_env (); @@ -78,7 +79,7 @@ _init_classes () } gboolean -gst_android_graphics_imageformat_init () +gst_android_graphics_imageformat_init (void) { if (!_init_classes ()) { gst_android_graphics_imageformat_deinit (); @@ -89,7 +90,7 @@ gst_android_graphics_imageformat_init () } void -gst_android_graphics_imageformat_deinit () +gst_android_graphics_imageformat_deinit (void) { JNIEnv *env = gst_dvm_get_env (); @@ -105,7 +106,7 @@ gst_ag_imageformat_get_bits_per_pixel (gint format) JNIEnv *env = gst_dvm_get_env (); jint bpp = 0; - bpp = GST_DVM_STATIC_CALL(return -1, Int, + bpp = GST_DVM_STATIC_CALL (return -1, Int, android_graphics_imageformat, getBitsPerPixel, format); return bpp; diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index 3182a6516f..a532ec9ea1 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -32,10 +32,11 @@ static struct jclass klass; jmethodID constructor; jmethodID release; -} android_graphics_surfacetexture = {0}; +} android_graphics_surfacetexture = { +0}; static gboolean -_init_classes () +_init_classes (void) { JNIEnv *env = gst_dvm_get_env (); @@ -50,7 +51,7 @@ _init_classes () } gboolean -gst_android_graphics_surfacetexture_init () +gst_android_graphics_surfacetexture_init (void) { if (!_init_classes ()) { gst_android_graphics_surfacetexture_deinit (); @@ -61,7 +62,7 @@ gst_android_graphics_surfacetexture_init () } void -gst_android_graphics_surfacetexture_deinit () +gst_android_graphics_surfacetexture_deinit (void) { JNIEnv *env = gst_dvm_get_env (); @@ -105,7 +106,7 @@ gst_ag_surfacetexture_release (GstAGSurfaceTexture * self) { JNIEnv *env = gst_dvm_get_env (); - GST_DVM_CALL(, self->object, Void, android_graphics_surfacetexture, release); + GST_DVM_CALL (, self->object, Void, android_graphics_surfacetexture, release); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAGSurfaceTexture, self); diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 077aff2ef7..853504a232 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -46,7 +46,8 @@ static struct jmethodID stopPreview; jmethodID stopSmoothZoom; jmethodID unlock; -} android_hardware_camera = {0}; +} android_hardware_camera = { +0}; static struct { @@ -56,7 +57,9 @@ static struct jfieldID orientation; jint CAMERA_FACING_BACK; jint CAMERA_FACING_FRONT; -} android_hardware_camera_camerainfo = {0}; +} android_hardware_camera_camerainfo = { +0}; + gint CameraInfo_CAMERA_FACING_BACK; gint CameraInfo_CAMERA_FACING_FRONT; @@ -65,7 +68,8 @@ static struct jclass klass; jfieldID width; jfieldID height; -} android_hardware_camera_size = {0}; +} android_hardware_camera_size = { +0}; /* TODO: Add other parameters */ static struct @@ -82,32 +86,37 @@ static struct jmethodID setPreviewFpsRange; jmethodID setPreviewSize; jmethodID unflatten; -} android_hardware_camera_parameters = {0}; +} android_hardware_camera_parameters = { +0}; static struct { jclass klass; jmethodID iterator; -} java_util_list = {0}; +} java_util_list = { +0}; static struct { jclass klass; jmethodID hasNext; jmethodID next; -} java_util_iterator = {0}; +} java_util_iterator = { +0}; static struct { jclass klass; jmethodID intValue; -} java_lang_integer = {0}; +} java_lang_integer = { +0}; static struct { jclass klass; jmethodID constructor; -} com_gstreamer_gstahccallback = {0}; +} com_gstreamer_gstahccallback = { +0}; static void gst_ah_camera_on_preview_frame (JNIEnv * env, jclass klass, jbyteArray data, @@ -135,7 +144,7 @@ static JNINativeMethod native_methods[] = { }; static gboolean -_init_classes () +_init_classes (void) { JNIEnv *env = gst_dvm_get_env (); @@ -244,7 +253,7 @@ _init_classes () gboolean -gst_android_hardware_camera_init () +gst_android_hardware_camera_init (void) { if (!_init_classes ()) { gst_android_hardware_camera_deinit (); @@ -255,7 +264,7 @@ gst_android_hardware_camera_init () } void -gst_android_hardware_camera_deinit () +gst_android_hardware_camera_deinit (void) { JNIEnv *env = gst_dvm_get_env (); @@ -353,7 +362,7 @@ done: } gint -gst_ah_camera_get_number_of_cameras () +gst_ah_camera_get_number_of_cameras (void) { JNIEnv *env = gst_dvm_get_env (); gint num_cameras; From e78143f839284b81615bf8279a23aab7f2da8ac6 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 09:01:50 -0400 Subject: [PATCH 17/82] androidcamera: Add support for using DexLoader with Embeded GstAhcCallback.jar --- sys/androidcamera/Makefile.am | 38 ++++++- .../com/gstreamer/GstAhcCallback.java | 28 +++++ .../gst-android-hardware-camera.c | 100 +++++++++++++++++- sys/androidcamera/gstahccallback.h | 33 ++++++ 4 files changed, 193 insertions(+), 6 deletions(-) create mode 100644 sys/androidcamera/com/gstreamer/GstAhcCallback.java create mode 100644 sys/androidcamera/gstahccallback.h diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index 9d446e8e1b..bea49c16fd 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -6,14 +6,18 @@ libgstandroidcamera_la_SOURCES = \ gst-android-hardware-camera.c \ gst-android-graphics-surfacetexture.c \ gst-android-graphics-imageformat.c \ - gstahcsrc.c + gstahcsrc.c \ + gstahccallback.c + +JAVA_SOURCE = com/gstreamer/GstAhcCallback.java noinst_HEADERS = \ gst-dvm.h \ + gstahcsrc.h \ + gstahccallback.h \ gst-android-hardware-camera.h \ gst-android-graphics-surfacetexture.h \ - gst-android-graphics-imageformat.h \ - gstahcsrc.h + gst-android-graphics-imageformat.h libgstandroidcamera_la_CFLAGS = \ $(GST_PLUGINS_BASE_CFLAGS) \ @@ -27,7 +31,33 @@ libgstandroidcamera_la_LIBADD = \ libgstandroidcamera_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) libgstandroidcamera_la_LIBTOOLFLAGS = --tag=disable-static -EXTRA_DIST = $(VIDEO_BASE_CLASSES_C) $(VIDEO_BASE_CLASSES_H) +EXTRA_DIST = $(JAVA_SOURCE) +CLEANFILES = gstahccallback.c + +if HAVE_ANDROID_SDK +gstahccallback.c: $(JAVA_SOURCE) + @echo " JAVAC $(JAVA_SOURCE)" + @$(JAVAC) -target 1.6 -source 1.6 -nowarn -classpath $(ANDROID_SDK_DIR)/platforms/android-14/android.jar $(JAVA_SOURCE) + @echo " DEX $(JAVA_SOURCE:.java=.class)" + @$(ANDROID_SDK_DIR)/platform-tools/dx --dex --output GstAhcCallback.jar $(JAVA_SOURCE:.java=.class) + @echo " GEN $@" + @echo "#include \"gstahccallback.h\"" > $@ + @echo "" >> $@ + @echo "const static guint8 jar_file[] = {" >> $@ + @hexdump -v -e '" "' -e '8/1 "0x%02x, "' -e '"\n"' GstAhcCallback.jar | sed 's/0x ,//g' >> $@ + @echo "};" >> $@ + @echo "" >> $@ + @echo "const guint8 *gst_ahc_callback_jar = jar_file;" >> $@ + @echo "const gsize gst_ahc_callback_jar_size = sizeof(jar_file);" >> $@ + @rm -f GstAhcCallback.jar +else +gstahccallback.c: + @echo " GEN $@" + @echo "#include \"gstahccallback.h\"" > $@ + @echo "" >> $@ + @echo "const guint8 *gst_ahc_callback_jar = NULL;" >> $@ + @echo "const gsize gst_ahc_callback_jar_size = 0;" >> $@ +endif Android.mk: Makefile.am $(BUILT_SOURCES) androgenizer \ diff --git a/sys/androidcamera/com/gstreamer/GstAhcCallback.java b/sys/androidcamera/com/gstreamer/GstAhcCallback.java new file mode 100644 index 0000000000..45ce0e8550 --- /dev/null +++ b/sys/androidcamera/com/gstreamer/GstAhcCallback.java @@ -0,0 +1,28 @@ +package com.gstreamer; + +import android.hardware.Camera; + +public class GstAhcCallback implements Camera.PreviewCallback, Camera.ErrorCallback { + public long mUserData; + public long mCallback; + + public static native void gst_ah_camera_on_preview_frame(byte[] data, Camera camera, + long callback, long user_data); + public static native void gst_ah_camera_on_error(int error, Camera camera, + long callback, long user_data); + + public GstAhcCallback(long callback, long user_data) { + mCallback = callback; + mUserData = user_data; + } + + @Override + public void onPreviewFrame(byte[] data, Camera camera) { + gst_ah_camera_on_preview_frame(data, camera, mCallback, mUserData); + } + + @Override + public void onError(int error, Camera camera) { + gst_ah_camera_on_error(error, camera, mCallback, mUserData); + } +} diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 853504a232..3e1f697ca0 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -24,7 +24,9 @@ #endif #include "gst-dvm.h" +#include "gstahccallback.h" #include "gst-android-hardware-camera.h" +#include "stdio.h" static struct { @@ -238,8 +240,102 @@ _init_classes (void) GST_DVM_GET_METHOD (java_lang_integer, intValue, "()I"); /* com.gstreamer.GstAhcCallback */ - GST_DVM_GET_CLASS (com_gstreamer_gstahccallback, - "com/gstreamer/GstAhcCallback"); + if (gst_ahc_callback_jar) { + jclass dex_loader = NULL; + gchar *path = g_strdup_printf ("%s/GstAhcCallback.jar", g_getenv ("TMP")); + FILE *fd = fopen (path, "wb"); + + GST_WARNING ("Found embedded GstAhcCallback.jar, trying to load dynamically" + "from %s", path); + if (fd) { + if (fwrite (gst_ahc_callback_jar, gst_ahc_callback_jar_size, 1, fd) == 1) { + dex_loader = (*env)->FindClass (env, "dalvik/system/DexClassLoader"); + (*env)->ExceptionClear (env); + } + fclose (fd); + } + + if (dex_loader) { + jmethodID constructor; + jmethodID load_class; + + constructor = (*env)->GetMethodID (env, dex_loader, "", + "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" + "Ljava/lang/ClassLoader;)V"); + load_class = (*env)->GetMethodID (env, dex_loader, "loadClass", + "(Ljava/lang/String;)Ljava/lang/Class;"); + (*env)->ExceptionClear (env); + if (constructor && load_class) { + jstring dex_path = NULL; + jstring optimized_directory = NULL; + + dex_path = (*env)->NewStringUTF (env, path); + optimized_directory = (*env)->NewStringUTF (env, g_getenv ("TMP")); + (*env)->ExceptionClear (env); + if (dex_path && optimized_directory) { + jobject loader; + jobject parent = NULL; + jclass klass; + + klass = (*env)->FindClass (env, "java/lang/Class"); + (*env)->ExceptionClear (env); + if (klass) { + jmethodID get_class_loader; + + get_class_loader = (*env)->GetMethodID (env, klass, + "getClassLoader", "()Ljava/lang/ClassLoader;"); + (*env)->ExceptionClear (env); + if (get_class_loader) { + parent = (*env)->CallObjectMethod (env, klass, get_class_loader); + (*env)->ExceptionClear (env); + } + (*env)->DeleteLocalRef (env, klass); + } + loader = (*env)->NewObject (env, dex_loader, constructor, dex_path, + optimized_directory, NULL, parent); + (*env)->ExceptionClear (env); + if (loader) { + jstring class_name = NULL; + + class_name = (*env)->NewStringUTF (env, + "com/gstreamer/GstAhcCallback"); + (*env)->ExceptionClear (env); + if (class_name) { + jclass temp; + + temp = (*env)->CallObjectMethod (env, loader, load_class, + class_name); + (*env)->ExceptionClear (env); + if (temp) { + + GST_WARNING ("Successfully loaded embedded GstAhcCallback"); + com_gstreamer_gstahccallback.klass = (*env)->NewGlobalRef (env, + temp); + (*env)->DeleteLocalRef (env, temp); + } + (*env)->DeleteLocalRef (env, class_name); + } + (*env)->DeleteLocalRef (env, loader); + } + if (parent) + (*env)->DeleteLocalRef (env, parent); + } + if (dex_path) + (*env)->DeleteLocalRef (env, dex_path); + if (optimized_directory) + (*env)->DeleteLocalRef (env, optimized_directory); + } + (*env)->DeleteLocalRef (env, dex_loader); + g_free (path); + } + } else { + GST_WARNING ("Did not find embedded GstAhcCallback.jar, fallback to" + " FindClass"); + } + if (!com_gstreamer_gstahccallback.klass) { + GST_DVM_GET_CLASS (com_gstreamer_gstahccallback, + "com/gstreamer/GstAhcCallback"); + } GST_DVM_GET_CONSTRUCTOR (com_gstreamer_gstahccallback, constructor, "(JJ)V"); if ((*env)->RegisterNatives (env, com_gstreamer_gstahccallback.klass, diff --git a/sys/androidcamera/gstahccallback.h b/sys/androidcamera/gstahccallback.h new file mode 100644 index 0000000000..df4d6d20bf --- /dev/null +++ b/sys/androidcamera/gstahccallback.h @@ -0,0 +1,33 @@ +/* com/gstreamer/GstAhcCallbac.java wrapper header + * + * Copyright (C) 2012, Cisco Systems, Inc. + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GST_AHC_CALLBACK_H__ +#define __GST_AHC_CALLBACK_H__ + +#include + +G_BEGIN_DECLS + +extern const guint8 *gst_ahc_callback_jar; +extern const gsize gst_ahc_callback_jar_size; + +G_END_DECLS +#endif /* __GST_AHC_CALLBACK_H__ */ From aa390e1be463c5c786ecb920d2983fbe325404ea Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 10:12:52 -0400 Subject: [PATCH 18/82] androidmedia: Disable plugin if android-sdk isn't found and dynamically search for platform version --- sys/androidcamera/Makefile.am | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index bea49c16fd..fa62d7d470 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -37,9 +37,10 @@ CLEANFILES = gstahccallback.c if HAVE_ANDROID_SDK gstahccallback.c: $(JAVA_SOURCE) @echo " JAVAC $(JAVA_SOURCE)" - @$(JAVAC) -target 1.6 -source 1.6 -nowarn -classpath $(ANDROID_SDK_DIR)/platforms/android-14/android.jar $(JAVA_SOURCE) + @$(JAVAC) -target 1.6 -source 1.6 -nowarn \ + -classpath $(ANDROID_SDK_DIR)/platforms/android-$(ANDROID_PLATFORM)/android.jar $(JAVA_SOURCE) @echo " DEX $(JAVA_SOURCE:.java=.class)" - @$(ANDROID_SDK_DIR)/platform-tools/dx --dex --output GstAhcCallback.jar $(JAVA_SOURCE:.java=.class) + @$(DX) --dex --output GstAhcCallback.jar $(JAVA_SOURCE:.java=.class) @echo " GEN $@" @echo "#include \"gstahccallback.h\"" > $@ @echo "" >> $@ From 54f3337bd1e5a487446fcada3d819cfcec2c78d6 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 11:12:19 -0400 Subject: [PATCH 19/82] androidmedia: Fix small indentation issues --- sys/androidcamera/gstahcsrc.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index fbec0b1700..9094eaa455 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -105,7 +105,7 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) } static gboolean -_data_queue_check_full (GstDataQueue *queue, guint visible, +_data_queue_check_full (GstDataQueue * queue, guint visible, guint bytes, guint64 time, gpointer checkdata) { return FALSE; @@ -181,7 +181,8 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } } -typedef struct { +typedef struct +{ GstAHCSrc *self; jbyteArray array; jbyte *data; @@ -194,7 +195,7 @@ gst_ahc_src_buffer_free_func (gpointer priv) GstAHCSrc *self = data->self; JNIEnv *env = gst_dvm_get_env (); - (*env)->ReleaseByteArrayElements(env, data->array, data->data, JNI_ABORT); + (*env)->ReleaseByteArrayElements (env, data->array, data->data, JNI_ABORT); if (self->camera) gst_ah_camera_add_callback_buffer (self->camera, data->array); (*env)->DeleteGlobalRef (env, data->array); @@ -203,7 +204,7 @@ gst_ahc_src_buffer_free_func (gpointer priv) } static void -_data_queue_item_free (GstDataQueueItem *item) +_data_queue_item_free (GstDataQueueItem * item) { gst_buffer_unref (GST_BUFFER (item->object)); g_slice_free (GstDataQueueItem, item); From d4717a96398c7f9800f2bad464168ba73f2f676b Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 11:13:12 -0400 Subject: [PATCH 20/82] androidmedia: add a gst_ahc_src_close function --- sys/androidcamera/gstahcsrc.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 9094eaa455..62617189c6 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -43,6 +43,8 @@ static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); +static void gst_ahc_src_close (GstAHCSrc * self); + #define NUM_CALLBACK_BUFFERS 5 #define GST_AHC_SRC_CAPS_STR \ @@ -130,9 +132,7 @@ gst_ahc_src_dispose (GObject * object) { GstAHCSrc *self = GST_AHC_SRC (object); - if (self->camera) - gst_ah_camera_release (self->camera); - self->camera = NULL; + gst_ahc_src_close (self); if (self->texture) gst_ag_surfacetexture_release (self->texture); @@ -353,6 +353,15 @@ gst_ahc_src_open (GstAHCSrc * self) return (self->camera != NULL); } +static void +gst_ahc_src_close (GstAHCSrc * self) +{ + if (self->camera) + gst_ah_camera_release (self->camera); + self->camera = NULL; + +} + static GstStateChangeReturn gst_ahc_src_change_state (GstElement * element, GstStateChange transition) { @@ -400,9 +409,7 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) switch (transition) { case GST_STATE_CHANGE_READY_TO_NULL: - if (self->camera) - gst_ah_camera_release (self->camera); - self->camera = NULL; + gst_ahc_src_close (self); break; default: break; From dd27b89e951bbf15a7dcf468410dda391f3be76e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 11:13:37 -0400 Subject: [PATCH 21/82] androidmedia: Allocate/free texture when camera is open/closed --- sys/androidcamera/gstahcsrc.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 62617189c6..88e706bb64 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -121,7 +121,7 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) gst_base_src_set_do_timestamp (GST_BASE_SRC (self), FALSE); self->camera = NULL; - self->texture = gst_ag_surfacetexture_new (0); + self->texture = NULL; self->data = NULL; self->queue = gst_data_queue_new (_data_queue_check_full, NULL); self->caps = NULL; @@ -134,10 +134,6 @@ gst_ahc_src_dispose (GObject * object) gst_ahc_src_close (self); - if (self->texture) - gst_ag_surfacetexture_release (self->texture); - self->texture = NULL; - if (self->queue) g_object_unref (self->queue); self->queue = NULL; @@ -301,6 +297,7 @@ gst_ahc_src_open (GstAHCSrc * self) gst_ag_imageformat_get_bits_per_pixel (gst_ahc_parameters_get_preview_format (params)) / 8; gst_ahc_size_free (size); + self->texture = gst_ag_surfacetexture_new (0); gst_ah_camera_set_preview_texture (self->camera, self->texture); gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, self); @@ -360,6 +357,9 @@ gst_ahc_src_close (GstAHCSrc * self) gst_ah_camera_release (self->camera); self->camera = NULL; + if (self->texture) + gst_ag_surfacetexture_release (self->texture); + self->texture = NULL; } static GstStateChangeReturn From 0083adbbed4cb7308864c5c547a92e64731e7a7e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 11:14:00 -0400 Subject: [PATCH 22/82] androidmedia: Flush the queue when the source is stopped --- sys/androidcamera/gstahcsrc.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 88e706bb64..96cd1849c5 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -443,10 +443,11 @@ gst_ahc_src_stop (GstBaseSrc * bsrc) GstAHCSrc *self = GST_AHC_SRC (bsrc); GST_WARNING_OBJECT (self, "Stopping preview"); - if (self->camera) + if (self->camera) { + gst_data_queue_flush (self->queue); return gst_ah_camera_stop_preview (self->camera); - else - return TRUE; + } + return TRUE; } static gboolean From 4856d22b9f064fdd545b1725049d4006148a0854 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 23 Oct 2012 13:54:46 -0400 Subject: [PATCH 23/82] androidmedia: Drop the first buffer to have proper timestamping --- sys/androidcamera/gstahcsrc.c | 48 +++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 96cd1849c5..406ab983ea 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -212,11 +212,35 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GstAHCSrc *self = GST_AHC_SRC (user_data); JNIEnv *env = gst_dvm_get_env (); GstBuffer *buffer; - GstDataQueueItem *item = g_slice_new0 (GstDataQueueItem); - FreeFuncBuffer *malloc_data = g_slice_new0 (FreeFuncBuffer); + GstDataQueueItem *item = NULL; + FreeFuncBuffer *malloc_data = NULL; + GstClockTime timestamp = GST_CLOCK_TIME_NONE; + GstClockTime duration = 0; GstClock *clock; + if ((clock = GST_ELEMENT_CLOCK (self))) { + GstClockTime base_time = GST_ELEMENT_CAST (self)->base_time; + GstClockTime current_ts; + + gst_object_ref (clock); + current_ts = gst_clock_get_time (clock) - base_time; + if (GST_CLOCK_TIME_IS_VALID (self->previous_ts)) { + timestamp = self->previous_ts; + duration = current_ts - self->previous_ts; + } else { + /* Drop the first buffer */ + gst_ah_camera_add_callback_buffer (self->camera, data); + return; + } + self->previous_ts = current_ts; + gst_object_unref (clock); + gst_base_src_set_do_timestamp (GST_BASE_SRC (self), FALSE); + } else { + gst_base_src_set_do_timestamp (GST_BASE_SRC (self), TRUE); + } + //GST_WARNING_OBJECT (self, "Received data buffer %p", data); + malloc_data = g_slice_new0 (FreeFuncBuffer); malloc_data->self = self; malloc_data->array = (*env)->NewGlobalRef (env, data); malloc_data->data = (*env)->GetByteArrayElements (env, data, NULL); @@ -226,24 +250,12 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GST_BUFFER_SIZE (buffer) = self->buffer_size; GST_BUFFER_MALLOCDATA (buffer) = (gpointer) malloc_data; GST_BUFFER_FREE_FUNC (buffer) = gst_ahc_src_buffer_free_func; - GST_BUFFER_DURATION (buffer) = 0; - GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE; - if ((clock = GST_ELEMENT_CLOCK (self))) { - GstClockTime base_time = GST_ELEMENT_CAST (self)->base_time; - GstClockTime current_ts; - - gst_object_ref (clock); - current_ts = gst_clock_get_time (clock) - base_time; - if (GST_CLOCK_TIME_IS_VALID (self->previous_ts)) { - GST_BUFFER_TIMESTAMP (buffer) = self->previous_ts; - GST_BUFFER_DURATION (buffer) = current_ts - self->previous_ts; - } - self->previous_ts = current_ts; - gst_object_unref (clock); - } + GST_BUFFER_DURATION (buffer) = duration; + GST_BUFFER_TIMESTAMP (buffer) = timestamp; gst_buffer_set_caps (buffer, self->caps); + item = g_slice_new0 (GstDataQueueItem); item->object = GST_MINI_OBJECT (buffer); item->size = GST_BUFFER_SIZE (buffer); item->duration = GST_BUFFER_DURATION (buffer); @@ -481,8 +493,6 @@ gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) if (!gst_data_queue_pop (self->queue, &item)) return GST_FLOW_WRONG_STATE; - //GST_WARNING_OBJECT (self, "Received data buffer %p", data); - *buffer = GST_BUFFER (item->object); g_slice_free (GstDataQueueItem, item); From bb83c54a8749a6d438fd5f063e1b55b3be9d6784 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 24 Oct 2012 10:55:52 -0400 Subject: [PATCH 24/82] Add support for getcaps that probes the camera for capabilities --- sys/androidcamera/gstahcsrc.c | 209 ++++++++++++++++++++++++++-------- 1 file changed, 162 insertions(+), 47 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 406ab983ea..be621154fb 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -141,12 +141,160 @@ gst_ahc_src_dispose (GObject * object) G_OBJECT_CLASS (parent_class)->dispose (object); } +static gint +_compare_formats (int f1, int f2) +{ + if (f1 == f2) + return 0; + /* YV12 has priority */ + if (f1 == ImageFormat_YV12) + return -1; + if (f2 == ImageFormat_YV12) + return 1; + /* Then NV21 */ + if (f1 == ImageFormat_NV21) + return -1; + if (f2 == ImageFormat_NV21) + return 1; + /* Then we don't care */ + return f2 - f1; +} + +static gint +_compare_sizes (GstAHCSize * s1, GstAHCSize * s2) +{ + return ((s2->width * s2->height) - (s1->width * s1->height)); +} + + +static gint +_compare_ranges (int *r1, int *r2) +{ + if (r1[1] == r2[1]) + /* Smallest range */ + return (r1[1] - r1[0]) - (r2[1] - r2[0]); + else + /* Highest fps */ + return r2[1] - r1[1]; +} + static GstCaps * gst_ahc_src_getcaps (GstBaseSrc * src) { GstAHCSrc *self = GST_AHC_SRC (src); - return gst_caps_copy (self->caps); + if (self->camera) { + GstCaps *ret = gst_caps_new_empty (); + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *formats, *sizes, *ranges; + GList *i, *j, *k; + int previous_format = ImageFormat_UNKNOWN; + + formats = gst_ahc_parameters_get_supported_preview_formats (params); + formats = g_list_sort (formats, (GCompareFunc) _compare_formats); + sizes = gst_ahc_parameters_get_supported_preview_sizes (params); + sizes = g_list_sort (sizes, (GCompareFunc) _compare_sizes); + ranges = gst_ahc_parameters_get_supported_preview_fps_range (params); + ranges = g_list_sort (ranges, (GCompareFunc) _compare_ranges); + GST_WARNING_OBJECT (self, "Supported preview formats:"); + + for (i = formats; i; i = i->next) { + int f = GPOINTER_TO_INT (i->data); + GstStructure *format = NULL; + + /* Ignore duplicates */ + if (f == previous_format) + continue; + + /* Can't use switch/case because the values are not constants */ + if (f == ImageFormat_NV16) { + GST_WARNING_OBJECT (self, " NV16 (%d)", f); + format = gst_structure_new ("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '6'), + NULL); + } else if (f == ImageFormat_NV21) { + GST_WARNING_OBJECT (self, " NV21 (%d)", f); + format = gst_structure_new ("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '2', '1'), + NULL); + } else if (f == ImageFormat_RGB_565) { + GST_WARNING_OBJECT (self, " RGB565 (%d)", f); + format = gst_structure_new ("video/x-raw-rgb", + "bpp", G_TYPE_INT, 16, + "depth", G_TYPE_INT, 16, + "red_mask", G_TYPE_INT, 0xf800, + "green_mask", G_TYPE_INT, 0x07e0, + "blue_mask", G_TYPE_INT, 0x001f, + "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, NULL); + } else if (f == ImageFormat_YUY2) { + GST_WARNING_OBJECT (self, " YUY2 (%d)", f); + format = gst_structure_new ("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'), + NULL); + } else if (f == ImageFormat_YV12) { + GST_WARNING_OBJECT (self, " YV12 (%d)", f); + format = gst_structure_new ("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'V', '1', '2'), + NULL); + } + previous_format = f; + + if (format) { + for (j = sizes; j; j = j->next) { + GstAHCSize *s = j->data; + GstStructure *size; + + size = gst_structure_copy (format); + gst_structure_set (size, "width", G_TYPE_INT, s->width, + "height", G_TYPE_INT, s->height, + "interlaced", G_TYPE_BOOLEAN, FALSE, + "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, NULL); + + for (k = ranges; k; k = k->next) { + int *range = k->data; + GstStructure *s; + + s = gst_structure_copy (size); + if (range[0] == range[1]) { + gst_structure_set (s, "framerate", GST_TYPE_FRACTION, + range[0], 1000, NULL); + } else { + gst_structure_set (s, "framerate", GST_TYPE_FRACTION_RANGE, + range[0], 1000, range[1], 1000, NULL); + } + gst_caps_append_structure (ret, s); + } + gst_structure_free (size); + } + gst_structure_free (format); + } + } + GST_WARNING_OBJECT (self, "Supported preview sizes:"); + for (i = sizes; i; i = i->next) { + GstAHCSize *s = i->data; + + GST_WARNING_OBJECT (self, " %dx%d", s->width, s->height); + } + GST_WARNING_OBJECT (self, "Supported preview fps range:"); + for (i = ranges; i; i = i->next) { + int *range = i->data; + + GST_WARNING_OBJECT (self, " [%d, %d]", range[0], range[1]); + } + + gst_ahc_parameters_supported_preview_formats_free (formats); + gst_ahc_parameters_supported_preview_sizes_free (sizes); + gst_ahc_parameters_supported_preview_fps_range_free (ranges); + } + gst_ahc_parameters_free (params); + + return ret; + } else { + return NULL; + } } static void @@ -281,15 +429,19 @@ gst_ahc_src_open (GstAHCSrc * self) self->camera = gst_ah_camera_open (0); if (self->camera) { - GstAHCParameters *params; JNIEnv *env = gst_dvm_get_env (); - - params = gst_ah_camera_get_parameters (self->camera); + GstAHCParameters *params; + gint i; GST_WARNING_OBJECT (self, "Opened camera"); + + self->texture = gst_ag_surfacetexture_new (0); + gst_ah_camera_set_preview_texture (self->camera, self->texture); + gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, self); + + params = gst_ah_camera_get_parameters (self->camera); if (params) { GstAHCSize *size; - int i; GST_WARNING_OBJECT (self, "Params : %s", gst_ahc_parameters_flatten (params)); @@ -309,51 +461,14 @@ gst_ahc_src_open (GstAHCSrc * self) gst_ag_imageformat_get_bits_per_pixel (gst_ahc_parameters_get_preview_format (params)) / 8; gst_ahc_size_free (size); - self->texture = gst_ag_surfacetexture_new (0); - gst_ah_camera_set_preview_texture (self->camera, self->texture); - gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, - self); - - for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { - jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); - - gst_ah_camera_add_callback_buffer (self->camera, array); - (*env)->DeleteLocalRef (env, array); - } - - { - GList *list, *i; - - list = gst_ahc_parameters_get_supported_preview_formats (params); - GST_WARNING_OBJECT (self, "Supported preview formats:"); - for (i = list; i; i = i->next) { - int f = GPOINTER_TO_INT (i->data); - - GST_WARNING_OBJECT (self, " %d", f); - } - gst_ahc_parameters_supported_preview_formats_free (list); - - list = gst_ahc_parameters_get_supported_preview_sizes (params); - GST_WARNING_OBJECT (self, "Supported preview sizes:"); - for (i = list; i; i = i->next) { - GstAHCSize *s = i->data; - - GST_WARNING_OBJECT (self, " %dx%d", s->width, s->height); - } - gst_ahc_parameters_supported_preview_sizes_free (list); - - list = gst_ahc_parameters_get_supported_preview_fps_range (params); - GST_WARNING_OBJECT (self, "Supported preview fps range:"); - for (i = list; i; i = i->next) { - int *range = i->data; - - GST_WARNING_OBJECT (self, " [%d, %d]", range[0], range[1]); - } - gst_ahc_parameters_supported_preview_fps_range_free (list); - } gst_ahc_parameters_free (params); } + for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { + jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); + gst_ah_camera_add_callback_buffer (self->camera, array); + (*env)->DeleteLocalRef (env, array); + } } else { GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, ("Unable to open device '%d'.", 0), GST_ERROR_SYSTEM); From 25896c5ab78744ceafd4c3d124eb02ad7e377260 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 24 Oct 2012 13:59:59 -0400 Subject: [PATCH 25/82] androidcamera: Add caps negotiation support --- sys/androidcamera/gstahcsrc.c | 195 ++++++++++++++++++++++++++-------- sys/androidcamera/gstahcsrc.h | 7 +- 2 files changed, 155 insertions(+), 47 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index be621154fb..8d761151af 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -37,6 +37,8 @@ static void gst_ahc_src_dispose (GObject * object); static GstStateChangeReturn gst_ahc_src_change_state (GstElement * element, GstStateChange transition); static GstCaps *gst_ahc_src_getcaps (GstBaseSrc * src); +static gboolean gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps); +static void gst_ahc_src_fixate (GstBaseSrc * basesrc, GstCaps * caps); static gboolean gst_ahc_src_start (GstBaseSrc * bsrc); static gboolean gst_ahc_src_stop (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); @@ -44,6 +46,8 @@ static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); static void gst_ahc_src_close (GstAHCSrc * self); +static void gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data); +static void gst_ahc_src_on_error (int error, gpointer user_data); #define NUM_CALLBACK_BUFFERS 5 @@ -98,6 +102,8 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) element_class->change_state = gst_ahc_src_change_state; gstbasesrc_class->get_caps = gst_ahc_src_getcaps; + gstbasesrc_class->set_caps = gst_ahc_src_setcaps; + gstbasesrc_class->fixate = gst_ahc_src_fixate; gstbasesrc_class->start = gst_ahc_src_start; gstbasesrc_class->stop = gst_ahc_src_stop; gstbasesrc_class->unlock = gst_ahc_src_unlock; @@ -124,7 +130,7 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) self->texture = NULL; self->data = NULL; self->queue = gst_data_queue_new (_data_queue_check_full, NULL); - self->caps = NULL; + self->start = FALSE; } static void @@ -297,6 +303,141 @@ gst_ahc_src_getcaps (GstBaseSrc * src) } } +static void +gst_ahc_src_fixate (GstBaseSrc * src, GstCaps * caps) +{ + GstAHCSrc *self = GST_AHC_SRC (src); + GstStructure *s = gst_caps_get_structure (caps, 0); + const GValue *value; + + GST_WARNING_OBJECT (self, "Fixating : %s", gst_caps_to_string (caps)); + if (s) { + value = gst_structure_get_value (s, "framerate"); + if (value) { + const GValue *min, *max; + gint n, d; + + min = gst_value_get_fraction_range_min (value); + max = gst_value_get_fraction_range_max (value); + if (min) { + n = gst_value_get_fraction_numerator (min); + d = gst_value_get_fraction_denominator (min); + self->fps_min = n * 1000 / d; + } + if (max) { + n = gst_value_get_fraction_numerator (max); + d = gst_value_get_fraction_denominator (max); + self->fps_max = n * 1000 / d; + } + GST_WARNING_OBJECT (self, "Fps : [%d, %d]", self->fps_min, self->fps_max); + } + } + /* Let it fixate itself */ +} + +static gboolean +gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) +{ + GstAHCSrc *self = GST_AHC_SRC (src); + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = FALSE; + GstAHCParameters *params = NULL; + + if (!self->camera) { + GST_WARNING_OBJECT (self, "setcaps called without a camera available"); + goto end; + } + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GstVideoFormat format; + gint fmt; + gint width, height, fps_n, fps_d; + gint i; + + if (!gst_video_format_parse_caps (caps, &format, &width, &height) || + !gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)) { + GST_WARNING_OBJECT (self, "unable to parse video caps"); + goto end; + } + fps_n *= 1000 / fps_d; + if (fps_n < self->fps_min || fps_n > self->fps_max) { + self->fps_min = self->fps_max = fps_n; + } + + switch (format) { + case GST_VIDEO_FORMAT_YV12: + fmt = ImageFormat_YV12; + break; + case GST_VIDEO_FORMAT_NV21: + fmt = ImageFormat_NV21; + break; + case GST_VIDEO_FORMAT_YUY2: + fmt = ImageFormat_YUY2; + break; + case GST_VIDEO_FORMAT_RGB16: + fmt = ImageFormat_RGB_565; + break; + /* GST_VIDEO_FORMAT_NV16 doesn't exist */ + //case GST_VIDEO_FORMAT_NV16: + //fmt = ImageFormat_NV16; + //break; + default: + fmt = ImageFormat_UNKNOWN; + break; + } + + if (fmt == ImageFormat_UNKNOWN) { + GST_WARNING_OBJECT (self, "unsupported video format"); + goto end; + } + + gst_ahc_parameters_set_preview_size (params, width, height); + gst_ahc_parameters_set_preview_format (params, fmt); + gst_ahc_parameters_set_preview_fps_range (params, self->fps_min, + self->fps_max); + + GST_WARNING_OBJECT (self, "Setting camera parameters : %dx%d @ [%f, %f]", + width, height, self->fps_min / 1000.0, self->fps_max / 1000.0); + + if (!gst_ah_camera_set_parameters (self->camera, params)) { + GST_WARNING_OBJECT (self, "Unable to set video parameters"); + goto end; + } + + self->width = width; + self->height = height; + self->format = fmt; + self->buffer_size = width * height * + ((double) gst_ag_imageformat_get_bits_per_pixel (fmt) / 8); + + for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { + jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); + + gst_ah_camera_add_callback_buffer (self->camera, array); + (*env)->DeleteLocalRef (env, array); + } + ret = TRUE; + } + +end: + if (params) + gst_ahc_parameters_free (params); + + if (ret && self->start) { + ret = gst_ah_camera_start_preview (self->camera); + if (ret) { + /* Need to reset callbacks after every startPreview */ + gst_ah_camera_set_preview_callback_with_buffer (self->camera, + gst_ahc_src_on_preview_frame, self); + gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, + self); + self->start = FALSE; + } + } + return ret; +} + static void gst_ahc_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) @@ -401,8 +542,6 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GST_BUFFER_DURATION (buffer) = duration; GST_BUFFER_TIMESTAMP (buffer) = timestamp; - gst_buffer_set_caps (buffer, self->caps); - item = g_slice_new0 (GstDataQueueItem); item->object = GST_MINI_OBJECT (buffer); item->size = GST_BUFFER_SIZE (buffer); @@ -429,46 +568,10 @@ gst_ahc_src_open (GstAHCSrc * self) self->camera = gst_ah_camera_open (0); if (self->camera) { - JNIEnv *env = gst_dvm_get_env (); - GstAHCParameters *params; - gint i; - GST_WARNING_OBJECT (self, "Opened camera"); self->texture = gst_ag_surfacetexture_new (0); gst_ah_camera_set_preview_texture (self->camera, self->texture); - gst_ah_camera_set_error_callback (self->camera, gst_ahc_src_on_error, self); - - params = gst_ah_camera_get_parameters (self->camera); - if (params) { - GstAHCSize *size; - - GST_WARNING_OBJECT (self, "Params : %s", - gst_ahc_parameters_flatten (params)); - gst_ahc_parameters_set_preview_size (params, 1280, 720); - gst_ahc_parameters_set_preview_format (params, ImageFormat_YV12); - - GST_WARNING_OBJECT (self, "Setting new params (%d) : %s", - gst_ah_camera_set_parameters (self->camera, params), - gst_ahc_parameters_flatten (params)); - size = gst_ahc_parameters_get_preview_size (params); - self->caps = gst_caps_new_simple ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'V', '1', '2'), - "width", G_TYPE_INT, size->width, - "height", G_TYPE_INT, size->height, - "framerate", GST_TYPE_FRACTION, 30, 1, NULL); - self->buffer_size = size->width * size->height * - gst_ag_imageformat_get_bits_per_pixel - (gst_ahc_parameters_get_preview_format (params)) / 8; - gst_ahc_size_free (size); - gst_ahc_parameters_free (params); - } - for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { - jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); - - gst_ah_camera_add_callback_buffer (self->camera, array); - (*env)->DeleteLocalRef (env, array); - } } else { GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, ("Unable to open device '%d'.", 0), GST_ERROR_SYSTEM); @@ -552,13 +655,12 @@ gst_ahc_src_start (GstBaseSrc * bsrc) GST_WARNING_OBJECT (self, "Starting preview"); if (self->camera) { - gboolean ret = gst_ah_camera_start_preview (self->camera); - if (ret) { - self->previous_ts = GST_CLOCK_TIME_NONE; - gst_ah_camera_set_preview_callback_with_buffer (self->camera, - gst_ahc_src_on_preview_frame, self); - } - return ret; + self->previous_ts = GST_CLOCK_TIME_NONE; + self->fps_min = self->fps_max = self->width = self->height = 0; + self->format = ImageFormat_UNKNOWN; + self->start = TRUE; + + return TRUE; } else { return FALSE; } @@ -572,6 +674,7 @@ gst_ahc_src_stop (GstBaseSrc * bsrc) GST_WARNING_OBJECT (self, "Stopping preview"); if (self->camera) { gst_data_queue_flush (self->queue); + self->start = FALSE; return gst_ah_camera_stop_preview (self->camera); } return TRUE; diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index c28f0b640d..926e5b4cef 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -51,11 +51,16 @@ struct _GstAHCSrc GstAHCamera *camera; GstAGSurfaceTexture *texture; - GstCaps *caps; GList *data; GstDataQueue *queue; gint buffer_size; GstClockTime previous_ts; + gint format; + gint width; + gint height; + gint fps_min; + gint fps_max; + gboolean start; }; struct _GstAHCSrcClass From 1a2bcc769c698dcd6aa902c71134d8277b95c422 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 24 Oct 2012 15:25:54 -0400 Subject: [PATCH 26/82] androidcamera: Fix timestamping issue --- sys/androidcamera/gstahcsrc.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 8d761151af..fe44ff4c51 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -131,6 +131,7 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) self->data = NULL; self->queue = gst_data_queue_new (_data_queue_check_full, NULL); self->start = FALSE; + self->previous_ts = GST_CLOCK_TIME_NONE; } static void @@ -513,21 +514,18 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) gst_object_ref (clock); current_ts = gst_clock_get_time (clock) - base_time; + gst_object_unref (clock); if (GST_CLOCK_TIME_IS_VALID (self->previous_ts)) { timestamp = self->previous_ts; duration = current_ts - self->previous_ts; + self->previous_ts = current_ts; } else { /* Drop the first buffer */ + self->previous_ts = current_ts; gst_ah_camera_add_callback_buffer (self->camera, data); return; } - self->previous_ts = current_ts; - gst_object_unref (clock); - gst_base_src_set_do_timestamp (GST_BASE_SRC (self), FALSE); - } else { - gst_base_src_set_do_timestamp (GST_BASE_SRC (self), TRUE); } - //GST_WARNING_OBJECT (self, "Received data buffer %p", data); malloc_data = g_slice_new0 (FreeFuncBuffer); malloc_data->self = self; From f43897e839ba267ce6da095c19e9021baa0a5b39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 26 Oct 2012 11:46:23 +0200 Subject: [PATCH 27/82] androidcamera: Make sure to not call any callbacks after stopping the camera Fixes segfaults when rotating the device for example. --- sys/androidcamera/gst-android-hardware-camera.c | 6 ++++-- sys/androidcamera/gstahcsrc.c | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 3e1f697ca0..36204ea3c5 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -126,7 +126,8 @@ gst_ah_camera_on_preview_frame (JNIEnv * env, jclass klass, jbyteArray data, { GstAHCPreviewCallback cb = (GstAHCPreviewCallback) (gsize) callback; - cb (data, (gpointer) (gsize) user_data); + if (cb) + cb (data, (gpointer) (gsize) user_data); } static void @@ -135,7 +136,8 @@ gst_ah_camera_on_error (JNIEnv * env, jclass klass, jint error, { GstAHCErrorCallback cb = (GstAHCErrorCallback) (gsize) callback; - cb (error, (gpointer) (gsize) user_data); + if (cb) + cb (error, (gpointer) (gsize) user_data); } static JNINativeMethod native_methods[] = { diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index fe44ff4c51..7580bd58d1 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -139,8 +139,6 @@ gst_ahc_src_dispose (GObject * object) { GstAHCSrc *self = GST_AHC_SRC (object); - gst_ahc_src_close (self); - if (self->queue) g_object_unref (self->queue); self->queue = NULL; @@ -673,6 +671,8 @@ gst_ahc_src_stop (GstBaseSrc * bsrc) if (self->camera) { gst_data_queue_flush (self->queue); self->start = FALSE; + gst_ah_camera_set_preview_callback_with_buffer (self->camera, NULL, NULL); + gst_ah_camera_set_error_callback (self->camera, NULL, NULL); return gst_ah_camera_stop_preview (self->camera); } return TRUE; From 6cdd4745fe5681130b3ae00849f5c7e1a294cb24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 26 Oct 2012 11:57:47 +0200 Subject: [PATCH 28/82] androidcamera: Make sure we always have a valid camera source instance in the buffer free function --- sys/androidcamera/gstahcsrc.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 7580bd58d1..75e1179f11 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -483,6 +483,7 @@ gst_ahc_src_buffer_free_func (gpointer priv) if (self->camera) gst_ah_camera_add_callback_buffer (self->camera, data->array); (*env)->DeleteGlobalRef (env, data->array); + gst_object_unref (self); g_slice_free (FreeFuncBuffer, data); } @@ -526,7 +527,7 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) } //GST_WARNING_OBJECT (self, "Received data buffer %p", data); malloc_data = g_slice_new0 (FreeFuncBuffer); - malloc_data->self = self; + malloc_data->self = gst_object_ref (self); malloc_data->array = (*env)->NewGlobalRef (env, data); malloc_data->data = (*env)->GetByteArrayElements (env, data, NULL); From 08db4f267d257c1beca60a9c5ad4de699245fb68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 26 Oct 2012 12:19:55 +0200 Subject: [PATCH 29/82] androidcamera: Implement LATENCY query --- sys/androidcamera/gstahcsrc.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 75e1179f11..427a6da856 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -44,6 +44,7 @@ static gboolean gst_ahc_src_stop (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); +static gboolean gst_ahc_src_query (GstBaseSrc * bsrc, GstQuery * query); static void gst_ahc_src_close (GstAHCSrc * self); static void gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data); @@ -108,6 +109,7 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstbasesrc_class->stop = gst_ahc_src_stop; gstbasesrc_class->unlock = gst_ahc_src_unlock; gstbasesrc_class->unlock_stop = gst_ahc_src_unlock_stop; + gstbasesrc_class->query = gst_ahc_src_query; gstpushsrc_class->create = gst_ahc_src_create; } @@ -715,3 +717,31 @@ gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) return GST_FLOW_OK; } + +static gboolean +gst_ahc_src_query (GstBaseSrc * bsrc, GstQuery * query) +{ + GstAHCSrc *self = GST_AHC_SRC (bsrc); + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_LATENCY:{ + GstClockTime min, max; + + gst_query_parse_latency (query, NULL, &min, &max); + min = gst_util_uint64_scale (GST_SECOND, 1000, self->fps_max); + max = gst_util_uint64_scale (GST_SECOND, 1000, self->fps_min); + GST_DEBUG_OBJECT (self, + "Reporting latency min: %" GST_TIME_FORMAT " max: %" GST_TIME_FORMAT, + GST_TIME_ARGS (min), GST_TIME_ARGS (max)); + gst_query_set_latency (query, TRUE, min, max); + + return TRUE; + break; + } + default: + return GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query); + break; + } + + g_assert_not_reached (); +} From c633ecc3be27fd340a4d5959143ebe4b50e12dbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 26 Oct 2012 12:43:09 +0200 Subject: [PATCH 30/82] androidcamera: Improve negotiation And make sure we set an FPS range from the supported ones now instead of a potentially unsupported range. --- sys/androidcamera/gstahcsrc.c | 59 +++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 27 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 427a6da856..9ebc5bf37f 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -309,31 +309,15 @@ gst_ahc_src_fixate (GstBaseSrc * src, GstCaps * caps) { GstAHCSrc *self = GST_AHC_SRC (src); GstStructure *s = gst_caps_get_structure (caps, 0); - const GValue *value; - GST_WARNING_OBJECT (self, "Fixating : %s", gst_caps_to_string (caps)); - if (s) { - value = gst_structure_get_value (s, "framerate"); - if (value) { - const GValue *min, *max; - gint n, d; + GST_DEBUG_OBJECT (self, "Fixating : %" GST_PTR_FORMAT, caps); - min = gst_value_get_fraction_range_min (value); - max = gst_value_get_fraction_range_max (value); - if (min) { - n = gst_value_get_fraction_numerator (min); - d = gst_value_get_fraction_denominator (min); - self->fps_min = n * 1000 / d; - } - if (max) { - n = gst_value_get_fraction_numerator (max); - d = gst_value_get_fraction_denominator (max); - self->fps_max = n * 1000 / d; - } - GST_WARNING_OBJECT (self, "Fps : [%d, %d]", self->fps_min, self->fps_max); - } - } - /* Let it fixate itself */ + /* Width/height will be fixed already here, format will + * be left for fixation by the default handler. + * We only have to fixate framerate here, to the + * highest possible framerate. + */ + gst_structure_fixate_field_nearest_fraction (s, "framerate", G_MAXINT, 1); } static gboolean @@ -354,6 +338,7 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) GstVideoFormat format; gint fmt; gint width, height, fps_n, fps_d; + GList *ranges, *l; gint i; if (!gst_video_format_parse_caps (caps, &format, &width, &height) || @@ -362,8 +347,28 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) goto end; } fps_n *= 1000 / fps_d; - if (fps_n < self->fps_min || fps_n > self->fps_max) { - self->fps_min = self->fps_max = fps_n; + + /* Select the best range that contains our framerate. + * We *must* set a range of those returned by the camera + * according to the API docs and can't use a subset of any + * of those ranges. + */ + self->fps_max = self->fps_min = 0; + ranges = gst_ahc_parameters_get_supported_preview_fps_range (params); + ranges = g_list_sort (ranges, (GCompareFunc) _compare_ranges); + for (l = ranges; l; l = l->next) { + int *range = l->data; + + if (fps_n >= range[0] && fps_n <= range[1]) { + self->fps_min = range[0]; + self->fps_max = range[1]; + break; + } + } + gst_ahc_parameters_supported_preview_fps_range_free (ranges); + if (self->fps_max == 0) { + GST_ERROR_OBJECT (self, "Couldn't find an applicable FPS range"); + goto end; } switch (format) { @@ -398,8 +403,8 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) gst_ahc_parameters_set_preview_fps_range (params, self->fps_min, self->fps_max); - GST_WARNING_OBJECT (self, "Setting camera parameters : %dx%d @ [%f, %f]", - width, height, self->fps_min / 1000.0, self->fps_max / 1000.0); + GST_WARNING_OBJECT (self, "Setting camera parameters : %d %dx%d @ [%f, %f]", + fmt, width, height, self->fps_min / 1000.0, self->fps_max / 1000.0); if (!gst_ah_camera_set_parameters (self->camera, params)) { GST_WARNING_OBJECT (self, "Unable to set video parameters"); From 19e5238379cde3ed36cf145781353d778436b32b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Fri, 26 Oct 2012 12:57:50 +0200 Subject: [PATCH 31/82] androidcamera: Chose the smallest range that contains the target framerate --- sys/androidcamera/gstahcsrc.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 9ebc5bf37f..df569e2f9a 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -340,6 +340,7 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) gint width, height, fps_n, fps_d; GList *ranges, *l; gint i; + gint range_size = G_MAXINT; if (!gst_video_format_parse_caps (caps, &format, &width, &height) || !gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)) { @@ -352,6 +353,8 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) * We *must* set a range of those returned by the camera * according to the API docs and can't use a subset of any * of those ranges. + * We chose the smallest range that contains the target + * framerate. */ self->fps_max = self->fps_min = 0; ranges = gst_ahc_parameters_get_supported_preview_fps_range (params); @@ -359,10 +362,11 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) for (l = ranges; l; l = l->next) { int *range = l->data; - if (fps_n >= range[0] && fps_n <= range[1]) { + if (fps_n >= range[0] && fps_n <= range[1] && + range_size > (range[1] - range[0])) { self->fps_min = range[0]; self->fps_max = range[1]; - break; + range_size = range[1] - range[0]; } } gst_ahc_parameters_supported_preview_fps_range_free (ranges); From e3ba219494f6ff9bef5c34b2cb483061e8c2a064 Mon Sep 17 00:00:00 2001 From: Nicolas Dufresne Date: Thu, 21 Jan 2016 13:46:52 -0500 Subject: [PATCH 32/82] androidcamera: Fix debug output --- sys/androidcamera/gstahcsrc.c | 44 +++++++++++++++++------------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index df569e2f9a..7ec14a2ca8 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -206,7 +206,7 @@ gst_ahc_src_getcaps (GstBaseSrc * src) sizes = g_list_sort (sizes, (GCompareFunc) _compare_sizes); ranges = gst_ahc_parameters_get_supported_preview_fps_range (params); ranges = g_list_sort (ranges, (GCompareFunc) _compare_ranges); - GST_WARNING_OBJECT (self, "Supported preview formats:"); + GST_DEBUG_OBJECT (self, "Supported preview formats:"); for (i = formats; i; i = i->next) { int f = GPOINTER_TO_INT (i->data); @@ -218,17 +218,17 @@ gst_ahc_src_getcaps (GstBaseSrc * src) /* Can't use switch/case because the values are not constants */ if (f == ImageFormat_NV16) { - GST_WARNING_OBJECT (self, " NV16 (%d)", f); + GST_DEBUG_OBJECT (self, " NV16 (%d)", f); format = gst_structure_new ("video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '6'), NULL); } else if (f == ImageFormat_NV21) { - GST_WARNING_OBJECT (self, " NV21 (%d)", f); + GST_DEBUG_OBJECT (self, " NV21 (%d)", f); format = gst_structure_new ("video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '2', '1'), NULL); } else if (f == ImageFormat_RGB_565) { - GST_WARNING_OBJECT (self, " RGB565 (%d)", f); + GST_DEBUG_OBJECT (self, " RGB565 (%d)", f); format = gst_structure_new ("video/x-raw-rgb", "bpp", G_TYPE_INT, 16, "depth", G_TYPE_INT, 16, @@ -237,12 +237,12 @@ gst_ahc_src_getcaps (GstBaseSrc * src) "blue_mask", G_TYPE_INT, 0x001f, "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, NULL); } else if (f == ImageFormat_YUY2) { - GST_WARNING_OBJECT (self, " YUY2 (%d)", f); + GST_DEBUG_OBJECT (self, " YUY2 (%d)", f); format = gst_structure_new ("video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'), NULL); } else if (f == ImageFormat_YV12) { - GST_WARNING_OBJECT (self, " YV12 (%d)", f); + GST_DEBUG_OBJECT (self, " YV12 (%d)", f); format = gst_structure_new ("video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'V', '1', '2'), NULL); @@ -279,17 +279,17 @@ gst_ahc_src_getcaps (GstBaseSrc * src) gst_structure_free (format); } } - GST_WARNING_OBJECT (self, "Supported preview sizes:"); + GST_DEBUG_OBJECT (self, "Supported preview sizes:"); for (i = sizes; i; i = i->next) { GstAHCSize *s = i->data; - GST_WARNING_OBJECT (self, " %dx%d", s->width, s->height); + GST_DEBUG_OBJECT (self, " %dx%d", s->width, s->height); } - GST_WARNING_OBJECT (self, "Supported preview fps range:"); + GST_DEBUG_OBJECT (self, "Supported preview fps range:"); for (i = ranges; i; i = i->next) { int *range = i->data; - GST_WARNING_OBJECT (self, " [%d, %d]", range[0], range[1]); + GST_DEBUG_OBJECT (self, " [%d, %d]", range[0], range[1]); } gst_ahc_parameters_supported_preview_formats_free (formats); @@ -407,7 +407,7 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) gst_ahc_parameters_set_preview_fps_range (params, self->fps_min, self->fps_max); - GST_WARNING_OBJECT (self, "Setting camera parameters : %d %dx%d @ [%f, %f]", + GST_DEBUG_OBJECT (self, "Setting camera parameters : %d %dx%d @ [%f, %f]", fmt, width, height, self->fps_min / 1000.0, self->fps_max / 1000.0); if (!gst_ah_camera_set_parameters (self->camera, params)) { @@ -571,12 +571,12 @@ gst_ahc_src_on_error (int error, gpointer user_data) static gboolean gst_ahc_src_open (GstAHCSrc * self) { - GST_WARNING_OBJECT (self, "Openning camera"); + GST_DEBUG_OBJECT (self, "Openning camera"); self->camera = gst_ah_camera_open (0); if (self->camera) { - GST_WARNING_OBJECT (self, "Opened camera"); + GST_DEBUG_OBJECT (self, "Opened camera"); self->texture = gst_ag_surfacetexture_new (0); gst_ah_camera_set_preview_texture (self->camera, self->texture); @@ -612,19 +612,19 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) gint num_cams = gst_ah_camera_get_number_of_cameras (); gint i; - GST_WARNING_OBJECT (self, "Found %d cameras on the system", num_cams); + GST_DEBUG_OBJECT (self, "Found %d cameras on the system", num_cams); for (i = 0; i < num_cams; i++) { GstAHCCameraInfo info; if (gst_ah_camera_get_camera_info (i, &info)) { - GST_WARNING_OBJECT (self, "Camera info for %d", i); - GST_WARNING_OBJECT (self, " Facing: %s (%d)", + GST_DEBUG_OBJECT (self, "Camera info for %d", i); + GST_DEBUG_OBJECT (self, " Facing: %s (%d)", info.facing == CameraInfo_CAMERA_FACING_BACK ? "Back" : "Front", info.facing); - GST_WARNING_OBJECT (self, " Orientation: %d degrees", + GST_DEBUG_OBJECT (self, " Orientation: %d degrees", info.orientation); } else { - GST_WARNING_OBJECT (self, "Error getting camera info for %d", i); + GST_DEBUG_OBJECT (self, "Error getting camera info for %d", i); } } @@ -661,7 +661,7 @@ gst_ahc_src_start (GstBaseSrc * bsrc) { GstAHCSrc *self = GST_AHC_SRC (bsrc); - GST_WARNING_OBJECT (self, "Starting preview"); + GST_DEBUG_OBJECT (self, "Starting preview"); if (self->camera) { self->previous_ts = GST_CLOCK_TIME_NONE; self->fps_min = self->fps_max = self->width = self->height = 0; @@ -679,7 +679,7 @@ gst_ahc_src_stop (GstBaseSrc * bsrc) { GstAHCSrc *self = GST_AHC_SRC (bsrc); - GST_WARNING_OBJECT (self, "Stopping preview"); + GST_DEBUG_OBJECT (self, "Stopping preview"); if (self->camera) { gst_data_queue_flush (self->queue); self->start = FALSE; @@ -695,7 +695,7 @@ gst_ahc_src_unlock (GstBaseSrc * bsrc) { GstAHCSrc *self = GST_AHC_SRC (bsrc); - GST_WARNING_OBJECT (self, "Unlocking create"); + GST_DEBUG_OBJECT (self, "Unlocking create"); gst_data_queue_set_flushing (self->queue, TRUE); return TRUE; @@ -706,7 +706,7 @@ gst_ahc_src_unlock_stop (GstBaseSrc * bsrc) { GstAHCSrc *self = GST_AHC_SRC (bsrc); - GST_WARNING_OBJECT (self, "Stopping unlock"); + GST_DEBUG_OBJECT (self, "Stopping unlock"); gst_data_queue_set_flushing (self->queue, FALSE); return TRUE; From c85df6807dfa79c068cd45070f5fe3920229fdf3 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 09:44:31 -0400 Subject: [PATCH 33/82] androidcamera: If callback is NULL then set it to NULL in jni --- .../gst-android-hardware-camera.c | 44 ++++++++++--------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 36204ea3c5..55d68d97cc 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -247,7 +247,7 @@ _init_classes (void) gchar *path = g_strdup_printf ("%s/GstAhcCallback.jar", g_getenv ("TMP")); FILE *fd = fopen (path, "wb"); - GST_WARNING ("Found embedded GstAhcCallback.jar, trying to load dynamically" + GST_DEBUG ("Found embedded GstAhcCallback.jar, trying to load dynamically" "from %s", path); if (fd) { if (fwrite (gst_ahc_callback_jar, gst_ahc_callback_jar_size, 1, fd) == 1) { @@ -310,7 +310,7 @@ _init_classes (void) (*env)->ExceptionClear (env); if (temp) { - GST_WARNING ("Successfully loaded embedded GstAhcCallback"); + GST_DEBUG ("Successfully loaded embedded GstAhcCallback"); com_gstreamer_gstahccallback.klass = (*env)->NewGlobalRef (env, temp); (*env)->DeleteLocalRef (env, temp); @@ -562,17 +562,19 @@ gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, gpointer user_data) { JNIEnv *env = gst_dvm_get_env (); - jobject object; + jobject object = NULL; gboolean ret = FALSE; - object = (*env)->NewObject (env, - com_gstreamer_gstahccallback.klass, - com_gstreamer_gstahccallback.constructor, - *((jlong *) & cb), *((jlong *) & user_data)); - if (!object) { - GST_ERROR ("Failed to create callback object"); - (*env)->ExceptionClear (env); - goto done; + if (cb) { + object = (*env)->NewObject (env, + com_gstreamer_gstahccallback.klass, + com_gstreamer_gstahccallback.constructor, + *((jlong *) & cb), *((jlong *) & user_data)); + if (!object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + goto done; + } } AHC_CALL (goto done, Void, setErrorCallback, object); @@ -590,17 +592,19 @@ gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, GstAHCPreviewCallback cb, gpointer user_data) { JNIEnv *env = gst_dvm_get_env (); - jobject object; + jobject object = NULL; gboolean ret = FALSE; - object = (*env)->NewObject (env, - com_gstreamer_gstahccallback.klass, - com_gstreamer_gstahccallback.constructor, - *((jlong *) & cb), *((jlong *) & user_data)); - if (!object) { - GST_ERROR ("Failed to create callback object"); - (*env)->ExceptionClear (env); - goto done; + if (cb) { + object = (*env)->NewObject (env, + com_gstreamer_gstahccallback.klass, + com_gstreamer_gstahccallback.constructor, + *((jlong *) & cb), *((jlong *) & user_data)); + if (!object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + goto done; + } } AHC_CALL (goto done, Void, setPreviewCallbackWithBuffer, object); From 691ab727b01930c97d8474080ebb0e11b1a550a6 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 09:45:55 -0400 Subject: [PATCH 34/82] androicamera: if buffer size increases, then readd new buffers to the queue and drop old ones The on_preview callback gets called with NULL if the buffer in the queue is too small, so we need to handle the case where the array is NULL. Also there is a bug in the android source which makes it drop one of the buffers so if we had 5 buffers, and we renegotiate to a higher resolution, then we'd only get 4 calls to on_preview_frame with NULL, with one being dropped. This means we can't reallocate the buffers in the if (data == NULL) case because we might end up with 0 buffers in the end. --- sys/androidcamera/gstahcsrc.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 7ec14a2ca8..8ee70d6178 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -324,7 +324,6 @@ static gboolean gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) { GstAHCSrc *self = GST_AHC_SRC (src); - JNIEnv *env = gst_dvm_get_env (); gboolean ret = FALSE; GstAHCParameters *params = NULL; @@ -337,9 +336,8 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) if (params) { GstVideoFormat format; gint fmt; - gint width, height, fps_n, fps_d; + gint width, height, fps_n, fps_d, buffer_size; GList *ranges, *l; - gint i; gint range_size = G_MAXINT; if (!gst_video_format_parse_caps (caps, &format, &width, &height) || @@ -418,15 +416,22 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) self->width = width; self->height = height; self->format = fmt; - self->buffer_size = width * height * + buffer_size = width * height * ((double) gst_ag_imageformat_get_bits_per_pixel (fmt) / 8); + if (buffer_size > self->buffer_size) { + JNIEnv *env = gst_dvm_get_env (); + gint i; - for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { - jbyteArray array = (*env)->NewByteArray (env, self->buffer_size); + for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { + jbyteArray array = (*env)->NewByteArray (env, buffer_size); - gst_ah_camera_add_callback_buffer (self->camera, array); - (*env)->DeleteLocalRef (env, array); + if (array) { + gst_ah_camera_add_callback_buffer (self->camera, array); + (*env)->DeleteLocalRef (env, array); + } + } } + self->buffer_size = buffer_size; ret = TRUE; } @@ -518,6 +523,11 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GstClockTime duration = 0; GstClock *clock; + if (data == NULL) { + GST_DEBUG_OBJECT (self, "Size of array in queue is too small, dropping it"); + return; + } + if ((clock = GST_ELEMENT_CLOCK (self))) { GstClockTime base_time = GST_ELEMENT_CAST (self)->base_time; GstClockTime current_ts; @@ -580,6 +590,7 @@ gst_ahc_src_open (GstAHCSrc * self) self->texture = gst_ag_surfacetexture_new (0); gst_ah_camera_set_preview_texture (self->camera, self->texture); + self->buffer_size = 0; } else { GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, ("Unable to open device '%d'.", 0), GST_ERROR_SYSTEM); From acb15e4178a95511f527af18d310c6c2032a59d7 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 09:49:03 -0400 Subject: [PATCH 35/82] androidcamera: Drop frames if we don't have a clock and var rename --- sys/androidcamera/gstahcsrc.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 8ee70d6178..3cee7aefe7 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -440,6 +440,7 @@ end: gst_ahc_parameters_free (params); if (ret && self->start) { + GST_DEBUG_OBJECT (self, "Starting preview"); ret = gst_ah_camera_start_preview (self->camera); if (ret) { /* Need to reset callbacks after every startPreview */ @@ -512,7 +513,7 @@ _data_queue_item_free (GstDataQueueItem * item) } static void -gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) +gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) { GstAHCSrc *self = GST_AHC_SRC (user_data); JNIEnv *env = gst_dvm_get_env (); @@ -523,7 +524,7 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) GstClockTime duration = 0; GstClock *clock; - if (data == NULL) { + if (array == NULL) { GST_DEBUG_OBJECT (self, "Size of array in queue is too small, dropping it"); return; } @@ -542,15 +543,18 @@ gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data) } else { /* Drop the first buffer */ self->previous_ts = current_ts; - gst_ah_camera_add_callback_buffer (self->camera, data); + gst_ah_camera_add_callback_buffer (self->camera, array); return; } + } else { + gst_ah_camera_add_callback_buffer (self->camera, array); + return; } //GST_WARNING_OBJECT (self, "Received data buffer %p", data); malloc_data = g_slice_new0 (FreeFuncBuffer); malloc_data->self = gst_object_ref (self); - malloc_data->array = (*env)->NewGlobalRef (env, data); - malloc_data->data = (*env)->GetByteArrayElements (env, data, NULL); + malloc_data->array = (*env)->NewGlobalRef (env, array); + malloc_data->data = (*env)->GetByteArrayElements (env, array, NULL); buffer = gst_buffer_new (); GST_BUFFER_DATA (buffer) = (guint8 *) malloc_data->data; From 122083eadbad6d65b985534fd4d7ed5db70c5c30 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 09:49:39 -0400 Subject: [PATCH 36/82] androidcamera: Calling set_preview_callback with NULL frees all the buffers in the queue. We must not do it at the stop otherwise we lose all our buffers. It's best to do it during the close, so we free up the resources. --- sys/androidcamera/gstahcsrc.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 3cee7aefe7..ba67f84f3d 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -606,8 +606,11 @@ gst_ahc_src_open (GstAHCSrc * self) static void gst_ahc_src_close (GstAHCSrc * self) { - if (self->camera) + if (self->camera) { + gst_ah_camera_set_error_callback (self->camera, NULL, NULL); + gst_ah_camera_set_preview_callback_with_buffer (self->camera, NULL, NULL); gst_ah_camera_release (self->camera); + } self->camera = NULL; if (self->texture) @@ -698,7 +701,6 @@ gst_ahc_src_stop (GstBaseSrc * bsrc) if (self->camera) { gst_data_queue_flush (self->queue); self->start = FALSE; - gst_ah_camera_set_preview_callback_with_buffer (self->camera, NULL, NULL); gst_ah_camera_set_error_callback (self->camera, NULL, NULL); return gst_ah_camera_stop_preview (self->camera); } From 0552bb1b2a8238b22ce42e652801d466900cbf7b Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 10:12:06 -0400 Subject: [PATCH 37/82] androidcamera: Fix memleak and lose of buffer if the data queue is flushing --- sys/androidcamera/gstahcsrc.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index ba67f84f3d..d6b4cbbcb0 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -571,7 +571,10 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) item->visible = TRUE; item->destroy = (GDestroyNotify) _data_queue_item_free; - gst_data_queue_push (self->queue, item); + if (!gst_data_queue_push (self->queue, item)) { + /* Can't add buffer to queue. Must be flushing. */ + _data_queue_item_free (item); + } } static void From a08c89530381782d2db7e8235308545e2d2d866e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 11:35:36 -0400 Subject: [PATCH 38/82] androidcamera: Add device property and property probe it --- sys/androidcamera/gstahcsrc.c | 158 +++++++++++++++++++++++++++------- sys/androidcamera/gstahcsrc.h | 4 + 2 files changed, 131 insertions(+), 31 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index d6b4cbbcb0..f9d7399e97 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -24,10 +24,15 @@ #endif #include +#include #include "gstahcsrc.h" #include "gst-dvm.h" +static void gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface + * iface); +static void gst_ahc_src_init_interfaces (GType type); + static void gst_ahc_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_ahc_src_get_property (GObject * object, guint prop_id, @@ -67,9 +72,27 @@ GST_DEBUG_CATEGORY_STATIC (gst_ahc_src_debug); enum { - ARG_0, + PROP_0, + PROP_DEVICE, }; -GST_BOILERPLATE (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC); + +#define DEFAULT_DEVICE "0" + +GST_BOILERPLATE_FULL (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC, + gst_ahc_src_init_interfaces); + +static void +gst_ahc_src_init_interfaces (GType type) +{ + static const GInterfaceInfo ahcsrc_propertyprobe_info = { + (GInterfaceInitFunc) gst_ahc_src_property_probe_interface_init, + NULL, + NULL, + }; + + g_type_add_interface_static (type, GST_TYPE_PROPERTY_PROBE, + &ahcsrc_propertyprobe_info); +} static void gst_ahc_src_base_init (gpointer g_class) @@ -112,6 +135,13 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstbasesrc_class->query = gst_ahc_src_query; gstpushsrc_class->create = gst_ahc_src_create; + + g_object_class_install_property (gobject_class, PROP_DEVICE, + g_param_spec_string ("device", "device", + "Device ID", DEFAULT_DEVICE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); + + klass->probe_properties = NULL; } static gboolean @@ -148,6 +178,100 @@ gst_ahc_src_dispose (GObject * object) G_OBJECT_CLASS (parent_class)->dispose (object); } +static void +gst_ahc_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstAHCSrc *self = GST_AHC_SRC (object); + (void) self; + + switch (prop_id) { + case PROP_DEVICE:{ + const gchar *dev = g_value_get_string (value); + gchar *endptr = NULL; + guint64 device; + + device = g_ascii_strtoll (dev, &endptr, 10); + if (endptr != dev && endptr[0] == 0 && device < G_MAXINT) + self->device = (gint) device; + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_ahc_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstAHCSrc *self = GST_AHC_SRC (object); + (void) self; + + switch (prop_id) { + case PROP_DEVICE:{ + gchar *dev = g_strdup_printf ("%d", self->device); + + g_value_take_string (value, dev); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static const GList * +gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) +{ + GObjectClass *klass = G_OBJECT_GET_CLASS (probe); + GstAHCSrcClass *ahc_class = GST_AHC_SRC_CLASS (probe); + + + if (!ahc_class->probe_properties) + ahc_class->probe_properties = g_list_append (NULL, + g_object_class_find_property (klass, "device")); + + return ahc_class->probe_properties; +} + +static GValueArray * +gst_ahc_src_probe_get_values (GstPropertyProbe * probe, + guint prop_id, const GParamSpec * pspec) +{ + GValueArray *array = NULL; + + switch (prop_id) { + case PROP_DEVICE:{ + GValue value = { 0 }; + gint num_cams = gst_ah_camera_get_number_of_cameras (); + gint i; + + array = g_value_array_new (num_cams); + g_value_init (&value, G_TYPE_STRING); + for (i = 0; i < num_cams; i++) { + g_value_take_string (&value, g_strdup_printf ("%d", i)); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + break; + } + + return array; +} + +static void +gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface * iface) +{ + iface->get_properties = gst_ahc_src_probe_get_properties; + iface->get_values = gst_ahc_src_probe_get_values; +} + static gint _compare_formats (int f1, int f2) { @@ -454,34 +578,6 @@ end: return ret; } -static void -gst_ahc_src_set_property (GObject * object, guint prop_id, - const GValue * value, GParamSpec * pspec) -{ - GstAHCSrc *self = GST_AHC_SRC (object); - (void) self; - - switch (prop_id) { - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -gst_ahc_src_get_property (GObject * object, guint prop_id, - GValue * value, GParamSpec * pspec) -{ - GstAHCSrc *self = GST_AHC_SRC (object); - (void) self; - - switch (prop_id) { - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - typedef struct { GstAHCSrc *self; @@ -590,7 +686,7 @@ gst_ahc_src_open (GstAHCSrc * self) { GST_DEBUG_OBJECT (self, "Openning camera"); - self->camera = gst_ah_camera_open (0); + self->camera = gst_ah_camera_open (self->device); if (self->camera) { GST_DEBUG_OBJECT (self, "Opened camera"); diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index 926e5b4cef..1fe6c52a5b 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -61,11 +61,15 @@ struct _GstAHCSrc gint fps_min; gint fps_max; gboolean start; + + /* Properties */ + gint device; }; struct _GstAHCSrcClass { GstPushSrcClass parent_class; + GList *probe_properties; }; GType gst_ahc_src_get_type (void); From 02f36d92bc57670993c8ffca074d276ea20dbf62 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 30 Oct 2012 12:13:12 -0400 Subject: [PATCH 39/82] androidcamera: Adding device-orientation and device-facing properties --- sys/androidcamera/gstahcsrc.c | 70 ++++++++++++++++++++++++++--------- 1 file changed, 53 insertions(+), 17 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index f9d7399e97..53793cb857 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -74,6 +74,8 @@ enum { PROP_0, PROP_DEVICE, + PROP_DEVICE_FACING, + PROP_DEVICE_ORIENTATION, }; #define DEFAULT_DEVICE "0" @@ -81,6 +83,27 @@ enum GST_BOILERPLATE_FULL (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC, gst_ahc_src_init_interfaces); +#define CAMERA_FACING_BACK 0 +#define CAMERA_FACING_FRONT 1 + +static GType +gst_ahc_src_facing_get_type (void) +{ + static GType type = 0; + static const GEnumValue types[] = { + {CAMERA_FACING_BACK, "Back", "back"}, + {CAMERA_FACING_FRONT, "Front", "front"}, + {0, NULL, NULL} + }; + + if (!type) { + type = g_enum_register_static ("GstAHCSrcFacing", types); + } + return type; +} + +#define GST_AHC_SRC_FACING_TYPE (gst_ahc_src_facing_get_type()) + static void gst_ahc_src_init_interfaces (GType type) { @@ -141,6 +164,17 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) "Device ID", DEFAULT_DEVICE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (gobject_class, PROP_DEVICE_ORIENTATION, + g_param_spec_int ("device-orientation", "Device orientation", + "The orientation of the camera image", + 0, 360, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_DEVICE_FACING, + g_param_spec_enum ("device-facing", "Device facing", + "The direction that the camera faces", + GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + klass->probe_properties = NULL; } @@ -216,6 +250,25 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, g_value_take_string (value, dev); } break; + case PROP_DEVICE_FACING:{ + GstAHCCameraInfo info; + + if (gst_ah_camera_get_camera_info (self->device, &info)) + g_value_set_enum (value, info.facing == CameraInfo_CAMERA_FACING_BACK ? + CAMERA_FACING_BACK : CAMERA_FACING_FRONT); + else + g_value_set_enum (value, CAMERA_FACING_BACK); + } + break; + case PROP_DEVICE_ORIENTATION:{ + GstAHCCameraInfo info; + + if (gst_ah_camera_get_camera_info (self->device, &info)) + g_value_set_int (value, info.orientation); + else + g_value_set_int (value, 0); + } + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -727,23 +780,6 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) case GST_STATE_CHANGE_NULL_TO_READY: { gint num_cams = gst_ah_camera_get_number_of_cameras (); - gint i; - - GST_DEBUG_OBJECT (self, "Found %d cameras on the system", num_cams); - - for (i = 0; i < num_cams; i++) { - GstAHCCameraInfo info; - if (gst_ah_camera_get_camera_info (i, &info)) { - GST_DEBUG_OBJECT (self, "Camera info for %d", i); - GST_DEBUG_OBJECT (self, " Facing: %s (%d)", - info.facing == CameraInfo_CAMERA_FACING_BACK ? "Back" : "Front", - info.facing); - GST_DEBUG_OBJECT (self, " Orientation: %d degrees", - info.orientation); - } else { - GST_DEBUG_OBJECT (self, "Error getting camera info for %d", i); - } - } if (num_cams > 0) { if (!gst_ahc_src_open (self)) From 2e745fa1b16c9d7bda1d367655e95dac0af73de1 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 31 Oct 2012 14:21:47 -0400 Subject: [PATCH 40/82] androidcamera: Send proper error when unable to open camera --- sys/androidcamera/gstahcsrc.c | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 53793cb857..3933430221 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -748,8 +748,17 @@ gst_ahc_src_open (GstAHCSrc * self) gst_ah_camera_set_preview_texture (self->camera, self->texture); self->buffer_size = 0; } else { - GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, - ("Unable to open device '%d'.", 0), GST_ERROR_SYSTEM); + gint num_cams = gst_ah_camera_get_number_of_cameras (); + if (num_cams > 0 && self->device < num_cams) { + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, + ("Unable to open device '%d'.", self->device), GST_ERROR_SYSTEM); + } else if (num_cams > 0) { + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, + ("Device '%d' does not exist.", self->device), GST_ERROR_SYSTEM); + } else { + GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, + ("There are no cameras available on this device."), GST_ERROR_SYSTEM); + } } return (self->camera != NULL); @@ -778,19 +787,8 @@ gst_ahc_src_change_state (GstElement * element, GstStateChange transition) switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: - { - gint num_cams = gst_ah_camera_get_number_of_cameras (); - - if (num_cams > 0) { - if (!gst_ahc_src_open (self)) - return GST_STATE_CHANGE_FAILURE; - } else { - GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, - ("There are no cameras available on this device."), - GST_ERROR_SYSTEM); + if (!gst_ahc_src_open (self)) return GST_STATE_CHANGE_FAILURE; - } - } break; default: break; From 77ba73ca7ef9724409eb301aa07d96d5e898aa7e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Thu, 1 Nov 2012 11:58:33 -0400 Subject: [PATCH 41/82] androidcamera: Add more wrappers for the Camera.Parameters class --- .../gst-android-hardware-camera.c | 2198 ++++++++++++++++- .../gst-android-hardware-camera.h | 195 +- 2 files changed, 2348 insertions(+), 45 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 55d68d97cc..53d09e46e5 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -73,24 +73,154 @@ static struct } android_hardware_camera_size = { 0}; -/* TODO: Add other parameters */ static struct { jclass klass; jmethodID flatten; + jmethodID getAntibanding; + jmethodID getColorEffect; + jmethodID getExposureCompensation; + jmethodID getExposureCompensationStep; + jmethodID getFlashMode; + jmethodID getFocalLength; + jmethodID getFocusMode; + jmethodID getHorizontalViewAngle; + jmethodID getMaxExposureCompensation; + jmethodID getMaxZoom; + jmethodID getMinExposureCompensation; jmethodID getPreviewFormat; jmethodID getPreviewFpsRange; jmethodID getPreviewSize; + jmethodID getSceneMode; + jmethodID getSupportedAntibanding; + jmethodID getSupportedColorEffects; + jmethodID getSupportedFlashModes; + jmethodID getSupportedFocusModes; jmethodID getSupportedPreviewFormats; jmethodID getSupportedPreviewFpsRange; jmethodID getSupportedPreviewSizes; + jmethodID getSupportedSceneModes; + jmethodID getSupportedWhiteBalance; + jmethodID getVerticalViewAngle; + jmethodID getWhiteBalance; + jmethodID getZoom; + jmethodID getZoomRatios; + jmethodID isSmoothZoomSupported; + jmethodID isZoomSupported; + jmethodID setAntibanding; + jmethodID setColorEffect; + jmethodID setExposureCompensation; + jmethodID setFlashMode; + jmethodID setFocusMode; jmethodID setPreviewFormat; jmethodID setPreviewFpsRange; jmethodID setPreviewSize; + jmethodID setSceneMode; + jmethodID setWhiteBalance; + jmethodID setZoom; jmethodID unflatten; + jstring WHITE_BALANCE_AUTO; + jstring WHITE_BALANCE_INCANDESCENT; + jstring WHITE_BALANCE_FLUORESCENT; + jstring WHITE_BALANCE_WARM_FLUORESCENT; + jstring WHITE_BALANCE_DAYLIGHT; + jstring WHITE_BALANCE_CLOUDY_DAYLIGHT; + jstring WHITE_BALANCE_TWILIGHT; + jstring WHITE_BALANCE_SHADE; + jstring EFFECT_NONE; + jstring EFFECT_MONO; + jstring EFFECT_NEGATIVE; + jstring EFFECT_SOLARIZE; + jstring EFFECT_SEPIA; + jstring EFFECT_POSTERIZE; + jstring EFFECT_WHITEBOARD; + jstring EFFECT_BLACKBOARD; + jstring EFFECT_AQUA; + jstring ANTIBANDING_AUTO; + jstring ANTIBANDING_50HZ; + jstring ANTIBANDING_60HZ; + jstring ANTIBANDING_OFF; + jstring FLASH_MODE_OFF; + jstring FLASH_MODE_AUTO; + jstring FLASH_MODE_ON; + jstring FLASH_MODE_RED_EYE; + jstring FLASH_MODE_TORCH; + jstring SCENE_MODE_AUTO; + jstring SCENE_MODE_ACTION; + jstring SCENE_MODE_PORTRAIT; + jstring SCENE_MODE_LANDSCAPE; + jstring SCENE_MODE_NIGHT; + jstring SCENE_MODE_NIGHT_PORTRAIT; + jstring SCENE_MODE_THEATRE; + jstring SCENE_MODE_BEACH; + jstring SCENE_MODE_SNOW; + jstring SCENE_MODE_SUNSET; + jstring SCENE_MODE_STEADYPHOTO; + jstring SCENE_MODE_FIREWORKS; + jstring SCENE_MODE_SPORTS; + jstring SCENE_MODE_PARTY; + jstring SCENE_MODE_CANDLELIGHT; + jstring SCENE_MODE_BARCODE; + jstring FOCUS_MODE_AUTO; + jstring FOCUS_MODE_INFINITY; + jstring FOCUS_MODE_MACRO; + jstring FOCUS_MODE_FIXED; + jstring FOCUS_MODE_EDOF; + jstring FOCUS_MODE_CONTINUOUS_VIDEO; + jstring FOCUS_MODE_CONTINUOUS_PICTURE; } android_hardware_camera_parameters = { 0}; +const gchar *Parameters_WHITE_BALANCE_AUTO; +const gchar *Parameters_WHITE_BALANCE_INCANDESCENT; +const gchar *Parameters_WHITE_BALANCE_FLUORESCENT; +const gchar *Parameters_WHITE_BALANCE_WARM_FLUORESCENT; +const gchar *Parameters_WHITE_BALANCE_DAYLIGHT; +const gchar *Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT; +const gchar *Parameters_WHITE_BALANCE_TWILIGHT; +const gchar *Parameters_WHITE_BALANCE_SHADE; +const gchar *Parameters_EFFECT_NONE; +const gchar *Parameters_EFFECT_MONO; +const gchar *Parameters_EFFECT_NEGATIVE; +const gchar *Parameters_EFFECT_SOLARIZE; +const gchar *Parameters_EFFECT_SEPIA; +const gchar *Parameters_EFFECT_POSTERIZE; +const gchar *Parameters_EFFECT_WHITEBOARD; +const gchar *Parameters_EFFECT_BLACKBOARD; +const gchar *Parameters_EFFECT_AQUA; +const gchar *Parameters_ANTIBANDING_AUTO; +const gchar *Parameters_ANTIBANDING_50HZ; +const gchar *Parameters_ANTIBANDING_60HZ; +const gchar *Parameters_ANTIBANDING_OFF; +const gchar *Parameters_FLASH_MODE_OFF; +const gchar *Parameters_FLASH_MODE_AUTO; +const gchar *Parameters_FLASH_MODE_ON; +const gchar *Parameters_FLASH_MODE_RED_EYE; +const gchar *Parameters_FLASH_MODE_TORCH; +const gchar *Parameters_SCENE_MODE_AUTO; +const gchar *Parameters_SCENE_MODE_ACTION; +const gchar *Parameters_SCENE_MODE_PORTRAIT; +const gchar *Parameters_SCENE_MODE_LANDSCAPE; +const gchar *Parameters_SCENE_MODE_NIGHT; +const gchar *Parameters_SCENE_MODE_NIGHT_PORTRAIT; +const gchar *Parameters_SCENE_MODE_THEATRE; +const gchar *Parameters_SCENE_MODE_BEACH; +const gchar *Parameters_SCENE_MODE_SNOW; +const gchar *Parameters_SCENE_MODE_SUNSET; +const gchar *Parameters_SCENE_MODE_STEADYPHOTO; +const gchar *Parameters_SCENE_MODE_FIREWORKS; +const gchar *Parameters_SCENE_MODE_SPORTS; +const gchar *Parameters_SCENE_MODE_PARTY; +const gchar *Parameters_SCENE_MODE_CANDLELIGHT; +const gchar *Parameters_SCENE_MODE_BARCODE; +const gchar *Parameters_FOCUS_MODE_AUTO; +const gchar *Parameters_FOCUS_MODE_INFINITY; +const gchar *Parameters_FOCUS_MODE_MACRO; +const gchar *Parameters_FOCUS_MODE_FIXED; +const gchar *Parameters_FOCUS_MODE_EDOF; +const gchar *Parameters_FOCUS_MODE_CONTINUOUS_VIDEO; +const gchar *Parameters_FOCUS_MODE_CONTINUOUS_PICTURE; + static struct { jclass klass; @@ -113,6 +243,13 @@ static struct } java_lang_integer = { 0}; +static struct +{ + jclass klass; + jmethodID equals; +} java_lang_string = { +0}; + static struct { jclass klass; @@ -207,26 +344,684 @@ _init_classes (void) "android/hardware/Camera$Parameters"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, flatten, "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getAntibanding, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getColorEffect, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getExposureCompensation, "()I"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getExposureCompensationStep, "()F"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFlashMode, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFocusMode, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getHorizontalViewAngle, "()F"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getMaxExposureCompensation, "()I"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getMaxZoom, "()I"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getMinExposureCompensation, "()I"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFormat, "()I"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFpsRange, "([I)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewSize, "()Landroid/hardware/Camera$Size;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getSceneMode, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedAntibanding, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedColorEffects, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedFlashModes, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedFocusModes, "()Ljava/util/List;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getSupportedPreviewFormats, "()Ljava/util/List;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getSupportedPreviewFpsRange, "()Ljava/util/List;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getSupportedPreviewSizes, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedSceneModes, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + getSupportedWhiteBalance, "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getVerticalViewAngle, + "()F"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getWhiteBalance, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getZoom, "()I"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getZoomRatios, + "()Ljava/util/List;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, isSmoothZoomSupported, + "()Z"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, isZoomSupported, + "()Z"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setAntibanding, + "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setColorEffect, + "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + setExposureCompensation, "(I)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setFlashMode, + "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setFocusMode, + "(Ljava/lang/String;)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFormat, "(I)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFpsRange, "(II)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewSize, "(II)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setSceneMode, + "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setWhiteBalance, + "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setZoom, "(I)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, unflatten, "(Ljava/lang/String;)V"); + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, WHITE_BALANCE_AUTO, + Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_AUTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_AUTO, NULL); + { + jobject local = android_hardware_camera_parameters.WHITE_BALANCE_AUTO; + + android_hardware_camera_parameters.WHITE_BALANCE_AUTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_INCANDESCENT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_INCANDESCENT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT, NULL); + { + jobject local = + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT; + + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_FLUORESCENT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_FLUORESCENT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT, NULL); + { + jobject local = + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT; + + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_WARM_FLUORESCENT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_WARM_FLUORESCENT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT, NULL); + { + jobject local = + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT; + + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_DAYLIGHT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_DAYLIGHT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT, NULL); + { + jobject local = android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT; + + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_CLOUDY_DAYLIGHT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT, NULL); + { + jobject local = + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT; + + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + WHITE_BALANCE_TWILIGHT, Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_TWILIGHT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT, NULL); + { + jobject local = android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT; + + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, WHITE_BALANCE_SHADE, + Object, "Ljava/lang/String;"); + Parameters_WHITE_BALANCE_SHADE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_SHADE, NULL); + { + jobject local = android_hardware_camera_parameters.WHITE_BALANCE_SHADE; + + android_hardware_camera_parameters.WHITE_BALANCE_SHADE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_NONE, Object, + "Ljava/lang/String;"); + Parameters_EFFECT_NONE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_NONE, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_NONE; + + android_hardware_camera_parameters.EFFECT_NONE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_MONO, Object, + "Ljava/lang/String;"); + Parameters_EFFECT_MONO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_MONO, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_MONO; + + android_hardware_camera_parameters.EFFECT_MONO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_NEGATIVE, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_NEGATIVE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_NEGATIVE, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_NEGATIVE; + + android_hardware_camera_parameters.EFFECT_NEGATIVE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_SOLARIZE, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_SOLARIZE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_SOLARIZE, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_SOLARIZE; + + android_hardware_camera_parameters.EFFECT_SOLARIZE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_SEPIA, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_SEPIA = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_SEPIA, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_SEPIA; + + android_hardware_camera_parameters.EFFECT_SEPIA = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_POSTERIZE, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_POSTERIZE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_POSTERIZE, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_POSTERIZE; + + android_hardware_camera_parameters.EFFECT_POSTERIZE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_WHITEBOARD, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_WHITEBOARD = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_WHITEBOARD, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_WHITEBOARD; + + android_hardware_camera_parameters.EFFECT_WHITEBOARD = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_BLACKBOARD, + Object, "Ljava/lang/String;"); + Parameters_EFFECT_BLACKBOARD = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_BLACKBOARD, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_BLACKBOARD; + + android_hardware_camera_parameters.EFFECT_BLACKBOARD = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_AQUA, Object, + "Ljava/lang/String;"); + Parameters_EFFECT_AQUA = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_AQUA, NULL); + { + jobject local = android_hardware_camera_parameters.EFFECT_AQUA; + + android_hardware_camera_parameters.EFFECT_AQUA = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_AUTO, + Object, "Ljava/lang/String;"); + Parameters_ANTIBANDING_AUTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_AUTO, NULL); + { + jobject local = android_hardware_camera_parameters.ANTIBANDING_AUTO; + + android_hardware_camera_parameters.ANTIBANDING_AUTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_50HZ, + Object, "Ljava/lang/String;"); + Parameters_ANTIBANDING_50HZ = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_50HZ, NULL); + { + jobject local = android_hardware_camera_parameters.ANTIBANDING_50HZ; + + android_hardware_camera_parameters.ANTIBANDING_50HZ = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_60HZ, + Object, "Ljava/lang/String;"); + Parameters_ANTIBANDING_60HZ = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_60HZ, NULL); + { + jobject local = android_hardware_camera_parameters.ANTIBANDING_60HZ; + + android_hardware_camera_parameters.ANTIBANDING_60HZ = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_OFF, + Object, "Ljava/lang/String;"); + Parameters_ANTIBANDING_OFF = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_OFF, NULL); + { + jobject local = android_hardware_camera_parameters.ANTIBANDING_OFF; + + android_hardware_camera_parameters.ANTIBANDING_OFF = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_OFF, + Object, "Ljava/lang/String;"); + Parameters_FLASH_MODE_OFF = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_OFF, NULL); + { + jobject local = android_hardware_camera_parameters.FLASH_MODE_OFF; + + android_hardware_camera_parameters.FLASH_MODE_OFF = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_AUTO, + Object, "Ljava/lang/String;"); + Parameters_FLASH_MODE_AUTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_AUTO, NULL); + { + jobject local = android_hardware_camera_parameters.FLASH_MODE_AUTO; + + android_hardware_camera_parameters.FLASH_MODE_AUTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_ON, + Object, "Ljava/lang/String;"); + Parameters_FLASH_MODE_ON = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_ON, NULL); + { + jobject local = android_hardware_camera_parameters.FLASH_MODE_ON; + + android_hardware_camera_parameters.FLASH_MODE_ON = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_RED_EYE, + Object, "Ljava/lang/String;"); + Parameters_FLASH_MODE_RED_EYE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_RED_EYE, NULL); + { + jobject local = android_hardware_camera_parameters.FLASH_MODE_RED_EYE; + + android_hardware_camera_parameters.FLASH_MODE_RED_EYE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_TORCH, + Object, "Ljava/lang/String;"); + Parameters_FLASH_MODE_TORCH = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_TORCH, NULL); + { + jobject local = android_hardware_camera_parameters.FLASH_MODE_TORCH; + + android_hardware_camera_parameters.FLASH_MODE_TORCH = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_AUTO, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_AUTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_AUTO, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_AUTO; + + android_hardware_camera_parameters.SCENE_MODE_AUTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_ACTION, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_ACTION = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_ACTION, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_ACTION; + + android_hardware_camera_parameters.SCENE_MODE_ACTION = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_PORTRAIT, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_PORTRAIT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_PORTRAIT; + + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + SCENE_MODE_LANDSCAPE, Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_LANDSCAPE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE; + + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_NIGHT, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_NIGHT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_NIGHT; + + android_hardware_camera_parameters.SCENE_MODE_NIGHT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + SCENE_MODE_NIGHT_PORTRAIT, Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_NIGHT_PORTRAIT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT, NULL); + { + jobject local = + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT; + + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_THEATRE, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_THEATRE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_THEATRE, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_THEATRE; + + android_hardware_camera_parameters.SCENE_MODE_THEATRE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_BEACH, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_BEACH = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_BEACH, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_BEACH; + + android_hardware_camera_parameters.SCENE_MODE_BEACH = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SNOW, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_SNOW = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SNOW, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_SNOW; + + android_hardware_camera_parameters.SCENE_MODE_SNOW = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SUNSET, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_SUNSET = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SUNSET, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_SUNSET; + + android_hardware_camera_parameters.SCENE_MODE_SUNSET = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + SCENE_MODE_STEADYPHOTO, Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_STEADYPHOTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO; + + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + SCENE_MODE_FIREWORKS, Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_FIREWORKS = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_FIREWORKS; + + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SPORTS, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_SPORTS = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SPORTS, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_SPORTS; + + android_hardware_camera_parameters.SCENE_MODE_SPORTS = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_PARTY, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_PARTY = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_PARTY, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_PARTY; + + android_hardware_camera_parameters.SCENE_MODE_PARTY = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + SCENE_MODE_CANDLELIGHT, Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_CANDLELIGHT = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT; + + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_BARCODE, + Object, "Ljava/lang/String;"); + Parameters_SCENE_MODE_BARCODE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_BARCODE, NULL); + { + jobject local = android_hardware_camera_parameters.SCENE_MODE_BARCODE; + + android_hardware_camera_parameters.SCENE_MODE_BARCODE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_AUTO, + Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_AUTO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_AUTO, NULL); + { + jobject local = android_hardware_camera_parameters.FOCUS_MODE_AUTO; + + android_hardware_camera_parameters.FOCUS_MODE_AUTO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_INFINITY, + Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_INFINITY = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_INFINITY, NULL); + { + jobject local = android_hardware_camera_parameters.FOCUS_MODE_INFINITY; + + android_hardware_camera_parameters.FOCUS_MODE_INFINITY = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_MACRO, + Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_MACRO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_MACRO, NULL); + { + jobject local = android_hardware_camera_parameters.FOCUS_MODE_MACRO; + + android_hardware_camera_parameters.FOCUS_MODE_MACRO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_FIXED, + Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_FIXED = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_FIXED, NULL); + { + jobject local = android_hardware_camera_parameters.FOCUS_MODE_FIXED; + + android_hardware_camera_parameters.FOCUS_MODE_FIXED = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_EDOF, + Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_EDOF = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_EDOF, NULL); + { + jobject local = android_hardware_camera_parameters.FOCUS_MODE_EDOF; + + android_hardware_camera_parameters.FOCUS_MODE_EDOF = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + FOCUS_MODE_CONTINUOUS_VIDEO, Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_CONTINUOUS_VIDEO = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO, NULL); + { + jobject local = + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO; + + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, + FOCUS_MODE_CONTINUOUS_PICTURE, Object, "Ljava/lang/String;"); + Parameters_FOCUS_MODE_CONTINUOUS_PICTURE = + (*env)->GetStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE, NULL); + { + jobject local = + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE; + + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE = + (*env)->NewGlobalRef (env, local); + (*env)->DeleteLocalRef (env, local); + } + + /* java.lang.String */ + GST_DVM_GET_CLASS (java_lang_string, "java/lang/String"); + GST_DVM_GET_METHOD (java_lang_string, equals, "(Ljava/lang/Object;)Z"); /* java.util.List */ GST_DVM_GET_CLASS (java_util_list, "java/util/List"); @@ -381,6 +1176,448 @@ gst_android_hardware_camera_deinit (void) if (android_hardware_camera_parameters.klass) (*env)->DeleteGlobalRef (env, android_hardware_camera_parameters.klass); android_hardware_camera_parameters.klass = NULL; + if (Parameters_WHITE_BALANCE_AUTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_AUTO, + Parameters_WHITE_BALANCE_AUTO); + Parameters_WHITE_BALANCE_AUTO = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_AUTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_AUTO); + android_hardware_camera_parameters.WHITE_BALANCE_AUTO = NULL; + if (Parameters_WHITE_BALANCE_INCANDESCENT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT, + Parameters_WHITE_BALANCE_INCANDESCENT); + Parameters_WHITE_BALANCE_INCANDESCENT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT); + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT = NULL; + if (Parameters_WHITE_BALANCE_FLUORESCENT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT, + Parameters_WHITE_BALANCE_FLUORESCENT); + Parameters_WHITE_BALANCE_FLUORESCENT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT); + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT = NULL; + if (Parameters_WHITE_BALANCE_WARM_FLUORESCENT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT, + Parameters_WHITE_BALANCE_WARM_FLUORESCENT); + Parameters_WHITE_BALANCE_WARM_FLUORESCENT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT); + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT = NULL; + if (Parameters_WHITE_BALANCE_DAYLIGHT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT, + Parameters_WHITE_BALANCE_DAYLIGHT); + Parameters_WHITE_BALANCE_DAYLIGHT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT); + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT = NULL; + if (Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT, + Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT); + Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT); + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT = NULL; + if (Parameters_WHITE_BALANCE_TWILIGHT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT, + Parameters_WHITE_BALANCE_TWILIGHT); + Parameters_WHITE_BALANCE_TWILIGHT = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT); + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT = NULL; + if (Parameters_WHITE_BALANCE_SHADE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.WHITE_BALANCE_SHADE, + Parameters_WHITE_BALANCE_SHADE); + Parameters_WHITE_BALANCE_SHADE = NULL; + if (android_hardware_camera_parameters.WHITE_BALANCE_SHADE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.WHITE_BALANCE_SHADE); + android_hardware_camera_parameters.WHITE_BALANCE_SHADE = NULL; + if (Parameters_EFFECT_NONE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_NONE, Parameters_EFFECT_NONE); + Parameters_EFFECT_NONE = NULL; + if (android_hardware_camera_parameters.EFFECT_NONE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_NONE); + android_hardware_camera_parameters.EFFECT_NONE = NULL; + if (Parameters_EFFECT_MONO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_MONO, Parameters_EFFECT_MONO); + Parameters_EFFECT_MONO = NULL; + if (android_hardware_camera_parameters.EFFECT_MONO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_MONO); + android_hardware_camera_parameters.EFFECT_MONO = NULL; + if (Parameters_EFFECT_NEGATIVE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_NEGATIVE, + Parameters_EFFECT_NEGATIVE); + Parameters_EFFECT_NEGATIVE = NULL; + if (android_hardware_camera_parameters.EFFECT_NEGATIVE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_NEGATIVE); + android_hardware_camera_parameters.EFFECT_NEGATIVE = NULL; + if (Parameters_EFFECT_SOLARIZE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_SOLARIZE, + Parameters_EFFECT_SOLARIZE); + Parameters_EFFECT_SOLARIZE = NULL; + if (android_hardware_camera_parameters.EFFECT_SOLARIZE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_SOLARIZE); + android_hardware_camera_parameters.EFFECT_SOLARIZE = NULL; + if (Parameters_EFFECT_SEPIA) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_SEPIA, + Parameters_EFFECT_SEPIA); + Parameters_EFFECT_SEPIA = NULL; + if (android_hardware_camera_parameters.EFFECT_SEPIA) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_SEPIA); + android_hardware_camera_parameters.EFFECT_SEPIA = NULL; + if (Parameters_EFFECT_POSTERIZE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_POSTERIZE, + Parameters_EFFECT_POSTERIZE); + Parameters_EFFECT_POSTERIZE = NULL; + if (android_hardware_camera_parameters.EFFECT_POSTERIZE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_POSTERIZE); + android_hardware_camera_parameters.EFFECT_POSTERIZE = NULL; + if (Parameters_EFFECT_WHITEBOARD) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_WHITEBOARD, + Parameters_EFFECT_WHITEBOARD); + Parameters_EFFECT_WHITEBOARD = NULL; + if (android_hardware_camera_parameters.EFFECT_WHITEBOARD) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_WHITEBOARD); + android_hardware_camera_parameters.EFFECT_WHITEBOARD = NULL; + if (Parameters_EFFECT_BLACKBOARD) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_BLACKBOARD, + Parameters_EFFECT_BLACKBOARD); + Parameters_EFFECT_BLACKBOARD = NULL; + if (android_hardware_camera_parameters.EFFECT_BLACKBOARD) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_BLACKBOARD); + android_hardware_camera_parameters.EFFECT_BLACKBOARD = NULL; + if (Parameters_EFFECT_AQUA) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.EFFECT_AQUA, Parameters_EFFECT_AQUA); + Parameters_EFFECT_AQUA = NULL; + if (android_hardware_camera_parameters.EFFECT_AQUA) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.EFFECT_AQUA); + android_hardware_camera_parameters.EFFECT_AQUA = NULL; + if (Parameters_ANTIBANDING_AUTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_AUTO, + Parameters_ANTIBANDING_AUTO); + Parameters_ANTIBANDING_AUTO = NULL; + if (android_hardware_camera_parameters.ANTIBANDING_AUTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.ANTIBANDING_AUTO); + android_hardware_camera_parameters.ANTIBANDING_AUTO = NULL; + if (Parameters_ANTIBANDING_50HZ) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_50HZ, + Parameters_ANTIBANDING_50HZ); + Parameters_ANTIBANDING_50HZ = NULL; + if (android_hardware_camera_parameters.ANTIBANDING_50HZ) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.ANTIBANDING_50HZ); + android_hardware_camera_parameters.ANTIBANDING_50HZ = NULL; + if (Parameters_ANTIBANDING_60HZ) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_60HZ, + Parameters_ANTIBANDING_60HZ); + Parameters_ANTIBANDING_60HZ = NULL; + if (android_hardware_camera_parameters.ANTIBANDING_60HZ) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.ANTIBANDING_60HZ); + android_hardware_camera_parameters.ANTIBANDING_60HZ = NULL; + if (Parameters_ANTIBANDING_OFF) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.ANTIBANDING_OFF, + Parameters_ANTIBANDING_OFF); + Parameters_ANTIBANDING_OFF = NULL; + if (android_hardware_camera_parameters.ANTIBANDING_OFF) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.ANTIBANDING_OFF); + android_hardware_camera_parameters.ANTIBANDING_OFF = NULL; + if (Parameters_FLASH_MODE_OFF) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_OFF, + Parameters_FLASH_MODE_OFF); + Parameters_FLASH_MODE_OFF = NULL; + if (android_hardware_camera_parameters.FLASH_MODE_OFF) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FLASH_MODE_OFF); + android_hardware_camera_parameters.FLASH_MODE_OFF = NULL; + if (Parameters_FLASH_MODE_AUTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_AUTO, + Parameters_FLASH_MODE_AUTO); + Parameters_FLASH_MODE_AUTO = NULL; + if (android_hardware_camera_parameters.FLASH_MODE_AUTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FLASH_MODE_AUTO); + android_hardware_camera_parameters.FLASH_MODE_AUTO = NULL; + if (Parameters_FLASH_MODE_ON) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_ON, + Parameters_FLASH_MODE_ON); + Parameters_FLASH_MODE_ON = NULL; + if (android_hardware_camera_parameters.FLASH_MODE_ON) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FLASH_MODE_ON); + android_hardware_camera_parameters.FLASH_MODE_ON = NULL; + if (Parameters_FLASH_MODE_RED_EYE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_RED_EYE, + Parameters_FLASH_MODE_RED_EYE); + Parameters_FLASH_MODE_RED_EYE = NULL; + if (android_hardware_camera_parameters.FLASH_MODE_RED_EYE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FLASH_MODE_RED_EYE); + android_hardware_camera_parameters.FLASH_MODE_RED_EYE = NULL; + if (Parameters_FLASH_MODE_TORCH) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FLASH_MODE_TORCH, + Parameters_FLASH_MODE_TORCH); + Parameters_FLASH_MODE_TORCH = NULL; + if (android_hardware_camera_parameters.FLASH_MODE_TORCH) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FLASH_MODE_TORCH); + android_hardware_camera_parameters.FLASH_MODE_TORCH = NULL; + if (Parameters_SCENE_MODE_AUTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_AUTO, + Parameters_SCENE_MODE_AUTO); + Parameters_SCENE_MODE_AUTO = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_AUTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_AUTO); + android_hardware_camera_parameters.SCENE_MODE_AUTO = NULL; + if (Parameters_SCENE_MODE_ACTION) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_ACTION, + Parameters_SCENE_MODE_ACTION); + Parameters_SCENE_MODE_ACTION = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_ACTION) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_ACTION); + android_hardware_camera_parameters.SCENE_MODE_ACTION = NULL; + if (Parameters_SCENE_MODE_PORTRAIT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT, + Parameters_SCENE_MODE_PORTRAIT); + Parameters_SCENE_MODE_PORTRAIT = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_PORTRAIT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT); + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT = NULL; + if (Parameters_SCENE_MODE_LANDSCAPE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE, + Parameters_SCENE_MODE_LANDSCAPE); + Parameters_SCENE_MODE_LANDSCAPE = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE); + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE = NULL; + if (Parameters_SCENE_MODE_NIGHT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT, + Parameters_SCENE_MODE_NIGHT); + Parameters_SCENE_MODE_NIGHT = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_NIGHT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT); + android_hardware_camera_parameters.SCENE_MODE_NIGHT = NULL; + if (Parameters_SCENE_MODE_NIGHT_PORTRAIT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT, + Parameters_SCENE_MODE_NIGHT_PORTRAIT); + Parameters_SCENE_MODE_NIGHT_PORTRAIT = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT); + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT = NULL; + if (Parameters_SCENE_MODE_THEATRE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_THEATRE, + Parameters_SCENE_MODE_THEATRE); + Parameters_SCENE_MODE_THEATRE = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_THEATRE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_THEATRE); + android_hardware_camera_parameters.SCENE_MODE_THEATRE = NULL; + if (Parameters_SCENE_MODE_BEACH) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_BEACH, + Parameters_SCENE_MODE_BEACH); + Parameters_SCENE_MODE_BEACH = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_BEACH) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_BEACH); + android_hardware_camera_parameters.SCENE_MODE_BEACH = NULL; + if (Parameters_SCENE_MODE_SNOW) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SNOW, + Parameters_SCENE_MODE_SNOW); + Parameters_SCENE_MODE_SNOW = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_SNOW) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_SNOW); + android_hardware_camera_parameters.SCENE_MODE_SNOW = NULL; + if (Parameters_SCENE_MODE_SUNSET) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SUNSET, + Parameters_SCENE_MODE_SUNSET); + Parameters_SCENE_MODE_SUNSET = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_SUNSET) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_SUNSET); + android_hardware_camera_parameters.SCENE_MODE_SUNSET = NULL; + if (Parameters_SCENE_MODE_STEADYPHOTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO, + Parameters_SCENE_MODE_STEADYPHOTO); + Parameters_SCENE_MODE_STEADYPHOTO = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO); + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO = NULL; + if (Parameters_SCENE_MODE_FIREWORKS) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS, + Parameters_SCENE_MODE_FIREWORKS); + Parameters_SCENE_MODE_FIREWORKS = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_FIREWORKS) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS); + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS = NULL; + if (Parameters_SCENE_MODE_SPORTS) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_SPORTS, + Parameters_SCENE_MODE_SPORTS); + Parameters_SCENE_MODE_SPORTS = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_SPORTS) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_SPORTS); + android_hardware_camera_parameters.SCENE_MODE_SPORTS = NULL; + if (Parameters_SCENE_MODE_PARTY) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_PARTY, + Parameters_SCENE_MODE_PARTY); + Parameters_SCENE_MODE_PARTY = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_PARTY) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_PARTY); + android_hardware_camera_parameters.SCENE_MODE_PARTY = NULL; + if (Parameters_SCENE_MODE_CANDLELIGHT) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT, + Parameters_SCENE_MODE_CANDLELIGHT); + Parameters_SCENE_MODE_CANDLELIGHT = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT); + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT = NULL; + if (Parameters_SCENE_MODE_BARCODE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.SCENE_MODE_BARCODE, + Parameters_SCENE_MODE_BARCODE); + Parameters_SCENE_MODE_BARCODE = NULL; + if (android_hardware_camera_parameters.SCENE_MODE_BARCODE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.SCENE_MODE_BARCODE); + android_hardware_camera_parameters.SCENE_MODE_BARCODE = NULL; + if (Parameters_FOCUS_MODE_AUTO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_AUTO, + Parameters_FOCUS_MODE_AUTO); + Parameters_FOCUS_MODE_AUTO = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_AUTO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_AUTO); + android_hardware_camera_parameters.FOCUS_MODE_AUTO = NULL; + if (Parameters_FOCUS_MODE_INFINITY) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_INFINITY, + Parameters_FOCUS_MODE_INFINITY); + Parameters_FOCUS_MODE_INFINITY = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_INFINITY) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_INFINITY); + android_hardware_camera_parameters.FOCUS_MODE_INFINITY = NULL; + if (Parameters_FOCUS_MODE_MACRO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_MACRO, + Parameters_FOCUS_MODE_MACRO); + Parameters_FOCUS_MODE_MACRO = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_MACRO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_MACRO); + android_hardware_camera_parameters.FOCUS_MODE_MACRO = NULL; + if (Parameters_FOCUS_MODE_FIXED) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_FIXED, + Parameters_FOCUS_MODE_FIXED); + Parameters_FOCUS_MODE_FIXED = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_FIXED) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_FIXED); + android_hardware_camera_parameters.FOCUS_MODE_FIXED = NULL; + if (Parameters_FOCUS_MODE_EDOF) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_EDOF, + Parameters_FOCUS_MODE_EDOF); + Parameters_FOCUS_MODE_EDOF = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_EDOF) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_EDOF); + android_hardware_camera_parameters.FOCUS_MODE_EDOF = NULL; + if (Parameters_FOCUS_MODE_CONTINUOUS_VIDEO) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO, + Parameters_FOCUS_MODE_CONTINUOUS_VIDEO); + Parameters_FOCUS_MODE_CONTINUOUS_VIDEO = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO); + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO = NULL; + if (Parameters_FOCUS_MODE_CONTINUOUS_PICTURE) + (*env)->ReleaseStringUTFChars (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE, + Parameters_FOCUS_MODE_CONTINUOUS_PICTURE); + Parameters_FOCUS_MODE_CONTINUOUS_PICTURE = NULL; + if (android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE) + (*env)->DeleteGlobalRef (env, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE); + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE = NULL; + + if (java_lang_string.klass) + (*env)->DeleteGlobalRef (env, java_lang_string.klass); + java_lang_string.klass = NULL; if (java_util_list.klass) (*env)->DeleteGlobalRef (env, java_util_list.klass); @@ -697,6 +1934,13 @@ gst_ahc_size_free (GstAHCSize * self) g_slice_free (GstAHCSize, self); } +/* java.lang.String */ +static jboolean +java_lang_string_equals (JNIEnv * env, jstring str, jstring obj) +{ + return (*env)->CallBooleanMethod (env, str, java_lang_string.equals, obj); +} + /* java.util.List */ static jobject java_util_list_iterator (JNIEnv * env, jobject obj) @@ -704,6 +1948,7 @@ java_util_list_iterator (JNIEnv * env, jobject obj) return (*env)->CallObjectMethod (env, obj, java_util_list.iterator); } +/* java.util.Iterator */ static jobject java_util_iterator_next (JNIEnv * env, jobject obj) { @@ -716,6 +1961,7 @@ java_util_iterator_has_next (JNIEnv * env, jobject obj) return (*env)->CallBooleanMethod (env, obj, java_util_iterator.hasNext); } +/* java.lang.Integer */ static jint java_lang_integer_int_value (JNIEnv * env, jobject obj) { @@ -730,6 +1976,372 @@ java_lang_integer_int_value (JNIEnv * env, jobject obj) GST_DVM_STATIC_CALL (error_statement, type, \ android_hardware_camera_parameters, method, ## __VA_ARGS__); +static const gchar * +_white_balance_to_gchar (JNIEnv * env, jstring white_balance) +{ + if (!white_balance) + return NULL; + + if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_AUTO)) + return Parameters_WHITE_BALANCE_AUTO; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT)) + return Parameters_WHITE_BALANCE_INCANDESCENT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT)) + return Parameters_WHITE_BALANCE_FLUORESCENT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT)) + return Parameters_WHITE_BALANCE_WARM_FLUORESCENT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT)) + return Parameters_WHITE_BALANCE_DAYLIGHT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT)) + return Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT)) + return Parameters_WHITE_BALANCE_TWILIGHT; + else if (java_lang_string_equals (env, white_balance, + android_hardware_camera_parameters.WHITE_BALANCE_SHADE)) + return Parameters_WHITE_BALANCE_SHADE; + + return NULL; +} + +static jstring +_white_balance_to_jstring (const gchar * white_balance) +{ + if (!white_balance) + return NULL; + + if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_AUTO)) + return android_hardware_camera_parameters.WHITE_BALANCE_AUTO; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_INCANDESCENT)) + return android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_FLUORESCENT)) + return android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT; + else if (!g_strcmp0 (white_balance, + Parameters_WHITE_BALANCE_WARM_FLUORESCENT)) + return android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_DAYLIGHT)) + return android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT)) + return android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_TWILIGHT)) + return android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT; + else if (!g_strcmp0 (white_balance, Parameters_WHITE_BALANCE_SHADE)) + return android_hardware_camera_parameters.WHITE_BALANCE_SHADE; + + return NULL; +} + +static const gchar * +_color_effect_to_gchar (JNIEnv * env, jstring color_effect) +{ + if (!color_effect) + return NULL; + + if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_NONE)) + return Parameters_EFFECT_NONE; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_MONO)) + return Parameters_EFFECT_MONO; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_NEGATIVE)) + return Parameters_EFFECT_NEGATIVE; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_SOLARIZE)) + return Parameters_EFFECT_SOLARIZE; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_SEPIA)) + return Parameters_EFFECT_SEPIA; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_POSTERIZE)) + return Parameters_EFFECT_POSTERIZE; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_WHITEBOARD)) + return Parameters_EFFECT_WHITEBOARD; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_BLACKBOARD)) + return Parameters_EFFECT_BLACKBOARD; + else if (java_lang_string_equals (env, color_effect, + android_hardware_camera_parameters.EFFECT_AQUA)) + return Parameters_EFFECT_AQUA; + + return NULL; +} + +static jstring +_color_effect_to_jstring (const gchar * color_effect) +{ + if (!color_effect) + return NULL; + + if (!g_strcmp0 (color_effect, Parameters_EFFECT_NONE)) + return android_hardware_camera_parameters.EFFECT_NONE; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_MONO)) + return android_hardware_camera_parameters.EFFECT_MONO; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_NEGATIVE)) + return android_hardware_camera_parameters.EFFECT_NEGATIVE; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_SOLARIZE)) + return android_hardware_camera_parameters.EFFECT_SOLARIZE; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_SEPIA)) + return android_hardware_camera_parameters.EFFECT_SEPIA; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_POSTERIZE)) + return android_hardware_camera_parameters.EFFECT_POSTERIZE; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_WHITEBOARD)) + return android_hardware_camera_parameters.EFFECT_WHITEBOARD; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_BLACKBOARD)) + return android_hardware_camera_parameters.EFFECT_BLACKBOARD; + else if (!g_strcmp0 (color_effect, Parameters_EFFECT_AQUA)) + return android_hardware_camera_parameters.EFFECT_AQUA; + + return NULL; +} + +static const gchar * +_antibanding_to_gchar (JNIEnv * env, jstring antibanding) +{ + if (!antibanding) + return NULL; + + if (java_lang_string_equals (env, antibanding, + android_hardware_camera_parameters.ANTIBANDING_AUTO)) + return Parameters_ANTIBANDING_AUTO; + else if (java_lang_string_equals (env, antibanding, + android_hardware_camera_parameters.ANTIBANDING_50HZ)) + return Parameters_ANTIBANDING_50HZ; + else if (java_lang_string_equals (env, antibanding, + android_hardware_camera_parameters.ANTIBANDING_60HZ)) + return Parameters_ANTIBANDING_60HZ; + else if (java_lang_string_equals (env, antibanding, + android_hardware_camera_parameters.ANTIBANDING_OFF)) + return Parameters_ANTIBANDING_OFF; + + return NULL; +} + +static jstring +_antibanding_to_jstring (const gchar * antibanding) +{ + if (!antibanding) + return NULL; + + if (!g_strcmp0 (antibanding, Parameters_ANTIBANDING_AUTO)) + return android_hardware_camera_parameters.ANTIBANDING_AUTO; + else if (!g_strcmp0 (antibanding, Parameters_ANTIBANDING_50HZ)) + return android_hardware_camera_parameters.ANTIBANDING_50HZ; + else if (!g_strcmp0 (antibanding, Parameters_ANTIBANDING_60HZ)) + return android_hardware_camera_parameters.ANTIBANDING_60HZ; + else if (!g_strcmp0 (antibanding, Parameters_ANTIBANDING_OFF)) + return android_hardware_camera_parameters.ANTIBANDING_OFF; + + return NULL; +} + +static const gchar * +_flash_mode_to_gchar (JNIEnv * env, jstring flash_mode) +{ + if (!flash_mode) + return NULL; + + if (java_lang_string_equals (env, flash_mode, + android_hardware_camera_parameters.FLASH_MODE_OFF)) + return Parameters_FLASH_MODE_OFF; + else if (java_lang_string_equals (env, flash_mode, + android_hardware_camera_parameters.FLASH_MODE_AUTO)) + return Parameters_FLASH_MODE_AUTO; + else if (java_lang_string_equals (env, flash_mode, + android_hardware_camera_parameters.FLASH_MODE_ON)) + return Parameters_FLASH_MODE_ON; + else if (java_lang_string_equals (env, flash_mode, + android_hardware_camera_parameters.FLASH_MODE_RED_EYE)) + return Parameters_FLASH_MODE_RED_EYE; + else if (java_lang_string_equals (env, flash_mode, + android_hardware_camera_parameters.FLASH_MODE_TORCH)) + return Parameters_FLASH_MODE_TORCH; + + return NULL; +} + +static jstring +_flash_mode_to_jstring (const gchar * flash_mode) +{ + if (!flash_mode) + return NULL; + + if (!g_strcmp0 (flash_mode, Parameters_FLASH_MODE_OFF)) + return android_hardware_camera_parameters.FLASH_MODE_OFF; + else if (!g_strcmp0 (flash_mode, Parameters_FLASH_MODE_AUTO)) + return android_hardware_camera_parameters.FLASH_MODE_AUTO; + else if (!g_strcmp0 (flash_mode, Parameters_FLASH_MODE_ON)) + return android_hardware_camera_parameters.FLASH_MODE_ON; + else if (!g_strcmp0 (flash_mode, Parameters_FLASH_MODE_RED_EYE)) + return android_hardware_camera_parameters.FLASH_MODE_RED_EYE; + else if (!g_strcmp0 (flash_mode, Parameters_FLASH_MODE_TORCH)) + return android_hardware_camera_parameters.FLASH_MODE_TORCH; + + return NULL; +} + +static const gchar * +_scene_mode_to_gchar (JNIEnv * env, jstring scene_mode) +{ + if (!scene_mode) + return NULL; + + if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_AUTO)) + return Parameters_SCENE_MODE_AUTO; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_ACTION)) + return Parameters_SCENE_MODE_ACTION; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_PORTRAIT)) + return Parameters_SCENE_MODE_PORTRAIT; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE)) + return Parameters_SCENE_MODE_LANDSCAPE; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_NIGHT)) + return Parameters_SCENE_MODE_NIGHT; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT)) + return Parameters_SCENE_MODE_NIGHT_PORTRAIT; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_THEATRE)) + return Parameters_SCENE_MODE_THEATRE; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_BEACH)) + return Parameters_SCENE_MODE_BEACH; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_SNOW)) + return Parameters_SCENE_MODE_SNOW; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_SUNSET)) + return Parameters_SCENE_MODE_SUNSET; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO)) + return Parameters_SCENE_MODE_STEADYPHOTO; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_FIREWORKS)) + return Parameters_SCENE_MODE_FIREWORKS; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_SPORTS)) + return Parameters_SCENE_MODE_SPORTS; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_PARTY)) + return Parameters_SCENE_MODE_PARTY; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT)) + return Parameters_SCENE_MODE_CANDLELIGHT; + else if (java_lang_string_equals (env, scene_mode, + android_hardware_camera_parameters.SCENE_MODE_BARCODE)) + return Parameters_SCENE_MODE_BARCODE; + + return NULL; +} + +static const jstring +_scene_mode_to_jstring (const gchar * scene_mode) +{ + if (!scene_mode) + return NULL; + + if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_AUTO)) + return android_hardware_camera_parameters.SCENE_MODE_AUTO; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_ACTION)) + return android_hardware_camera_parameters.SCENE_MODE_ACTION; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_PORTRAIT)) + return android_hardware_camera_parameters.SCENE_MODE_PORTRAIT; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_LANDSCAPE)) + return android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_NIGHT)) + return android_hardware_camera_parameters.SCENE_MODE_NIGHT; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_NIGHT_PORTRAIT)) + return android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_THEATRE)) + return android_hardware_camera_parameters.SCENE_MODE_THEATRE; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_BEACH)) + return android_hardware_camera_parameters.SCENE_MODE_BEACH; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_SNOW)) + return android_hardware_camera_parameters.SCENE_MODE_SNOW; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_SUNSET)) + return android_hardware_camera_parameters.SCENE_MODE_SUNSET; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_STEADYPHOTO)) + return android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_FIREWORKS)) + return android_hardware_camera_parameters.SCENE_MODE_FIREWORKS; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_SPORTS)) + return android_hardware_camera_parameters.SCENE_MODE_SPORTS; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_PARTY)) + return android_hardware_camera_parameters.SCENE_MODE_PARTY; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_CANDLELIGHT)) + return android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT; + else if (!g_strcmp0 (scene_mode, Parameters_SCENE_MODE_BARCODE)) + return android_hardware_camera_parameters.SCENE_MODE_BARCODE; + + return NULL; +} + +static const gchar * +_focus_mode_to_gchar (JNIEnv * env, jstring focus_mode) +{ + if (!focus_mode) + return NULL; + + if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_AUTO)) + return Parameters_FOCUS_MODE_AUTO; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_INFINITY)) + return Parameters_FOCUS_MODE_INFINITY; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_MACRO)) + return Parameters_FOCUS_MODE_MACRO; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_FIXED)) + return Parameters_FOCUS_MODE_FIXED; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_EDOF)) + return Parameters_FOCUS_MODE_EDOF; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) + return Parameters_FOCUS_MODE_CONTINUOUS_VIDEO; + else if (java_lang_string_equals (env, focus_mode, + android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) + return Parameters_FOCUS_MODE_CONTINUOUS_PICTURE; + + return NULL; +} + +static jstring +_focus_mode_to_jstring (const gchar * focus_mode) +{ + if (!focus_mode) + return NULL; + + if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_AUTO)) + return android_hardware_camera_parameters.FOCUS_MODE_AUTO; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_INFINITY)) + return android_hardware_camera_parameters.FOCUS_MODE_INFINITY; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_MACRO)) + return android_hardware_camera_parameters.FOCUS_MODE_MACRO; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_FIXED)) + return android_hardware_camera_parameters.FOCUS_MODE_FIXED; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_EDOF)) + return android_hardware_camera_parameters.FOCUS_MODE_EDOF; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_CONTINUOUS_VIDEO)) + return android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO; + else if (!g_strcmp0 (focus_mode, Parameters_FOCUS_MODE_CONTINUOUS_PICTURE)) + return android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE; + + return NULL; +} + gchar * gst_ahc_parameters_flatten (GstAHCParameters * self) { @@ -756,6 +2368,151 @@ done: return ret; } +const gchar * +gst_ahc_parameters_get_antibanding (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring antibanding; + + antibanding = AHCP_CALL (return NULL, Object, getAntibanding); + + ret = _antibanding_to_gchar (env, antibanding); + + if (antibanding) + (*env)->DeleteLocalRef (env, antibanding); + + return ret; +} + +const gchar * +gst_ahc_parameters_get_color_effect (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring color_effect; + + color_effect = AHCP_CALL (return NULL, Object, getColorEffect); + + ret = _color_effect_to_gchar (env, color_effect); + + if (color_effect) + (*env)->DeleteLocalRef (env, color_effect); + + return ret; +} + +gint +gst_ahc_parameters_get_exposure_compensation (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint ev; + + ev = AHCP_CALL (return -1, Int, getExposureCompensation); + + return ev; +} + +gfloat +gst_ahc_parameters_get_exposure_compensation_step (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gfloat step; + + step = AHCP_CALL (return 0.0, Float, getExposureCompensationStep); + + return step; +} + +const gchar * +gst_ahc_parameters_get_flash_mode (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring flash_mode; + + flash_mode = AHCP_CALL (return NULL, Object, getFlashMode); + + ret = _flash_mode_to_gchar (env, flash_mode); + + if (flash_mode) + (*env)->DeleteLocalRef (env, flash_mode); + + return ret; +} + +gfloat +gst_ahc_parameters_get_focal_length (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gfloat length; + + length = AHCP_CALL (return 0.0, Float, getFocalLength); + + return length; +} + +const gchar * +gst_ahc_parameters_get_focus_mode (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring focus_mode; + + focus_mode = AHCP_CALL (return NULL, Object, getFocusMode); + + ret = _focus_mode_to_gchar (env, focus_mode); + + if (focus_mode) + (*env)->DeleteLocalRef (env, focus_mode); + + return ret; +} + +gfloat +gst_ahc_parameters_get_horizontal_view_angle (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gfloat angle; + + angle = AHCP_CALL (return 0.0, Float, getHorizontalViewAngle); + + return angle; +} + +gint +gst_ahc_parameters_get_max_exposure_compensation (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint max; + + max = AHCP_CALL (return 0, Int, getMaxExposureCompensation); + + return max; +} + +gint +gst_ahc_parameters_get_max_zoom (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint max; + + max = AHCP_CALL (return -1, Int, getMaxZoom); + + return max; +} + +gint +gst_ahc_parameters_get_min_exposure_compensation (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint min; + + min = AHCP_CALL (return 0, Int, getMinExposureCompensation); + + return min; +} + gint gst_ahc_parameters_get_preview_format (GstAHCParameters * self) { @@ -844,6 +2601,163 @@ done: return size; } +const gchar * +gst_ahc_parameters_get_scene_mode (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring scene_mode; + + scene_mode = AHCP_CALL (return NULL, Object, getSceneMode); + + ret = _scene_mode_to_gchar (env, scene_mode); + + if (scene_mode) + (*env)->DeleteLocalRef (env, scene_mode); + + return ret; +} + +GList * +gst_ahc_parameters_get_supported_antibanding (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedAntibanding); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _antibanding_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_antibanding_free (GList * list) +{ + g_list_free (list); +} + +GList * +gst_ahc_parameters_get_supported_color_effects (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedColorEffects); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _color_effect_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_color_effects_free (GList * list) +{ + g_list_free (list); +} + +GList * +gst_ahc_parameters_get_supported_flash_modes (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedFlashModes); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _flash_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_flash_modes_free (GList * list) +{ + g_list_free (list); +} + +GList * +gst_ahc_parameters_get_supported_focus_modes (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedFocusModes); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _focus_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_focus_modes_free (GList * list) +{ + g_list_free (list); +} + GList * gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) { @@ -955,6 +2869,245 @@ gst_ahc_parameters_supported_preview_sizes_free (GList * list) g_list_free_full (list, (GDestroyNotify) gst_ahc_size_free); } +GList * +gst_ahc_parameters_get_supported_scene_modes (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedSceneModes); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _scene_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_scene_modes_free (GList * list) +{ + g_list_free (list); +} + +GList * +gst_ahc_parameters_get_supported_white_balance (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getSupportedWhiteBalance); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); + + if (str) { + const gchar *value = _white_balance_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_supported_white_balance_free (GList * list) +{ + g_list_free (list); +} + +gfloat +gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gfloat angle; + + angle = AHCP_CALL (return 0.0, Float, getVerticalViewAngle); + + return angle; +} + +const gchar * +gst_ahc_parameters_get_white_balance (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + const gchar *ret = NULL; + jstring white_balance; + + white_balance = AHCP_CALL (return NULL, Object, getWhiteBalance); + + ret = _white_balance_to_gchar (env, white_balance); + + if (white_balance) + (*env)->DeleteLocalRef (env, white_balance); + + return ret; +} + +gint +gst_ahc_parameters_get_zoom (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gint zoom; + + zoom = AHCP_CALL (return -1, Int, getZoom); + + return zoom; +} + +GList * +gst_ahc_parameters_get_zoom_ratios (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject list = NULL; + jobject iterator = NULL; + GList *ret = NULL; + + list = AHCP_CALL (return NULL, Object, getZoomRatios); + + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject integer = java_util_iterator_next (env, iterator); + + if (integer) { + jint value = java_lang_integer_int_value (env, integer); + + ret = g_list_append (ret, GINT_TO_POINTER (value)); + (*env)->DeleteLocalRef (env, integer); + } + } + (*env)->DeleteLocalRef (env, iterator); + } + (*env)->DeleteLocalRef (env, list); + + return ret; +} + +void +gst_ahc_parameters_zoom_ratios_free (GList * list) +{ + g_list_free (list); +} + +gboolean +gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean supported; + + supported = AHCP_CALL (return FALSE, Boolean, isSmoothZoomSupported); + + return supported; +} + +gboolean +gst_ahc_parameters_is_zoom_supported (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean supported; + + supported = AHCP_CALL (return FALSE, Boolean, isZoomSupported); + + return supported; +} + +gboolean +gst_ahc_parameters_set_antibanding (GstAHCParameters * self, + const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring antibanding; + + antibanding = _antibanding_to_jstring (value); + if (!antibanding) + return FALSE; + + AHCP_CALL (return FALSE, Void, setAntibanding, antibanding); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_color_effect (GstAHCParameters * self, + const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring color_effect; + + color_effect = _color_effect_to_jstring (value); + if (!color_effect) + return FALSE; + + AHCP_CALL (return FALSE, Void, setColorEffect, color_effect); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_exposure_compensation (GstAHCParameters * self, + gint value) +{ + JNIEnv *env = gst_dvm_get_env (); + + AHCP_CALL (return FALSE, Void, setExposureCompensation, value); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_flash_mode (GstAHCParameters * self, const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring flash_mode; + + flash_mode = _flash_mode_to_jstring (value); + if (!flash_mode) + return FALSE; + + AHCP_CALL (return FALSE, Void, setFlashMode, flash_mode); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_focus_mode (GstAHCParameters * self, const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring focus_mode; + + focus_mode = _focus_mode_to_jstring (value); + if (!focus_mode) + return FALSE; + + AHCP_CALL (return FALSE, Void, setFocusMode, focus_mode); + + return TRUE; +} + gboolean gst_ahc_parameters_set_preview_format (GstAHCParameters * self, gint format) { @@ -988,7 +3141,48 @@ gst_ahc_parameters_set_preview_size (GstAHCParameters * self, } gboolean -gst_ahc_parameters_unflatten (GstAHCParameters * self, gchar * flattened) +gst_ahc_parameters_set_scene_mode (GstAHCParameters * self, const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring scene_mode; + + scene_mode = _scene_mode_to_jstring (value); + if (!scene_mode) + return FALSE; + + AHCP_CALL (return FALSE, Void, setSceneMode, scene_mode); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_white_balance (GstAHCParameters * self, + const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring white_balance; + + white_balance = _white_balance_to_jstring (value); + if (!white_balance) + return FALSE; + + AHCP_CALL (return FALSE, Void, setWhiteBalance, white_balance); + + return TRUE; +} + +gboolean +gst_ahc_parameters_set_zoom (GstAHCParameters * self, gint value) +{ + JNIEnv *env = gst_dvm_get_env (); + + AHCP_CALL (return FALSE, Void, setZoom, value); + + return TRUE; +} + +gboolean +gst_ahc_parameters_unflatten (GstAHCParameters * self, const gchar * flattened) { JNIEnv *env = gst_dvm_get_env (); jstring v_str = NULL; diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index 2ff03f8d2e..d4246bc480 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -34,13 +34,15 @@ typedef struct _GstAHCSize GstAHCSize; typedef struct _GstAHCParameters GstAHCParameters; /* android.hardware.Camera */ -struct _GstAHCamera { +struct _GstAHCamera +{ /* < private > */ - jobject object; /* global reference */ + jobject object; /* global reference */ }; /* android.hardware.Camera.CameraInfo */ -struct _GstAHCCameraInfo { +struct _GstAHCCameraInfo +{ gint facing; gint orientation; }; @@ -48,16 +50,67 @@ extern gint CameraInfo_CAMERA_FACING_BACK; extern gint CameraInfo_CAMERA_FACING_FRONT; /* android.hardware.Camera.Size */ -struct _GstAHCSize { +struct _GstAHCSize +{ gint width; gint height; }; /* android.hardware.Camera.Parameters */ -struct _GstAHCParameters { +struct _GstAHCParameters +{ /* < private > */ - jobject object; /* global reference */ + jobject object; /* global reference */ }; +extern const gchar *Parameters_WHITE_BALANCE_AUTO; +extern const gchar *Parameters_WHITE_BALANCE_INCANDESCENT; +extern const gchar *Parameters_WHITE_BALANCE_FLUORESCENT; +extern const gchar *Parameters_WHITE_BALANCE_WARM_FLUORESCENT; +extern const gchar *Parameters_WHITE_BALANCE_DAYLIGHT; +extern const gchar *Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT; +extern const gchar *Parameters_WHITE_BALANCE_TWILIGHT; +extern const gchar *Parameters_WHITE_BALANCE_SHADE; +extern const gchar *Parameters_EFFECT_NONE; +extern const gchar *Parameters_EFFECT_MONO; +extern const gchar *Parameters_EFFECT_NEGATIVE; +extern const gchar *Parameters_EFFECT_SOLARIZE; +extern const gchar *Parameters_EFFECT_SEPIA; +extern const gchar *Parameters_EFFECT_POSTERIZE; +extern const gchar *Parameters_EFFECT_WHITEBOARD; +extern const gchar *Parameters_EFFECT_BLACKBOARD; +extern const gchar *Parameters_EFFECT_AQUA; +extern const gchar *Parameters_ANTIBANDING_AUTO; +extern const gchar *Parameters_ANTIBANDING_50HZ; +extern const gchar *Parameters_ANTIBANDING_60HZ; +extern const gchar *Parameters_ANTIBANDING_OFF; +extern const gchar *Parameters_FLASH_MODE_OFF; +extern const gchar *Parameters_FLASH_MODE_AUTO; +extern const gchar *Parameters_FLASH_MODE_ON; +extern const gchar *Parameters_FLASH_MODE_RED_EYE; +extern const gchar *Parameters_FLASH_MODE_TORCH; +extern const gchar *Parameters_SCENE_MODE_AUTO; +extern const gchar *Parameters_SCENE_MODE_ACTION; +extern const gchar *Parameters_SCENE_MODE_PORTRAIT; +extern const gchar *Parameters_SCENE_MODE_LANDSCAPE; +extern const gchar *Parameters_SCENE_MODE_NIGHT; +extern const gchar *Parameters_SCENE_MODE_NIGHT_PORTRAIT; +extern const gchar *Parameters_SCENE_MODE_THEATRE; +extern const gchar *Parameters_SCENE_MODE_BEACH; +extern const gchar *Parameters_SCENE_MODE_SNOW; +extern const gchar *Parameters_SCENE_MODE_SUNSET; +extern const gchar *Parameters_SCENE_MODE_STEADYPHOTO; +extern const gchar *Parameters_SCENE_MODE_FIREWORKS; +extern const gchar *Parameters_SCENE_MODE_SPORTS; +extern const gchar *Parameters_SCENE_MODE_PARTY; +extern const gchar *Parameters_SCENE_MODE_CANDLELIGHT; +extern const gchar *Parameters_SCENE_MODE_BARCODE; +extern const gchar *Parameters_FOCUS_MODE_AUTO; +extern const gchar *Parameters_FOCUS_MODE_INFINITY; +extern const gchar *Parameters_FOCUS_MODE_MACRO; +extern const gchar *Parameters_FOCUS_MODE_FIXED; +extern const gchar *Parameters_FOCUS_MODE_EDOF; +extern const gchar *Parameters_FOCUS_MODE_CONTINUOUS_VIDEO; +extern const gchar *Parameters_FOCUS_MODE_CONTINUOUS_PICTURE; /* android.hardware.Camera.ErrorCallback */ typedef void (*GstAHCErrorCallback) (gint error, gpointer user_data); @@ -69,57 +122,113 @@ gboolean gst_android_hardware_camera_init (void); void gst_android_hardware_camera_deinit (void); /* android.hardware.Camera */ -void gst_ah_camera_add_callback_buffer (GstAHCamera *self, - jbyteArray buffer); +void gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer); gboolean gst_ah_camera_get_camera_info (gint camera_id, - GstAHCCameraInfo *camera_info); + GstAHCCameraInfo * camera_info); gint gst_ah_camera_get_number_of_cameras (void); -GstAHCParameters *gst_ah_camera_get_parameters (GstAHCamera *self); -gboolean gst_ah_camera_lock (GstAHCamera *self); -GstAHCamera * gst_ah_camera_open (gint camera_id); -gboolean gst_ah_camera_reconnect (GstAHCamera *self); -void gst_ah_camera_release (GstAHCamera *self); -gboolean gst_ah_camera_set_parameters (GstAHCamera *self, - GstAHCParameters *params); -gboolean gst_ah_camera_set_error_callback (GstAHCamera *self, +GstAHCParameters *gst_ah_camera_get_parameters (GstAHCamera * self); +gboolean gst_ah_camera_lock (GstAHCamera * self); +GstAHCamera *gst_ah_camera_open (gint camera_id); +gboolean gst_ah_camera_reconnect (GstAHCamera * self); +void gst_ah_camera_release (GstAHCamera * self); +gboolean gst_ah_camera_set_parameters (GstAHCamera * self, + GstAHCParameters * params); +gboolean gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, gpointer user_data); -gboolean gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera *self, +gboolean gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, GstAHCPreviewCallback cb, gpointer user_data); -void gst_ah_camera_set_preview_texture (GstAHCamera *self, - GstAGSurfaceTexture *surfaceTexture); -gboolean gst_ah_camera_start_preview (GstAHCamera *self); -gboolean gst_ah_camera_start_smooth_zoom (GstAHCamera *self, gint value); -gboolean gst_ah_camera_stop_preview (GstAHCamera *self); -gboolean gst_ah_camera_stop_smooth_zoom (GstAHCamera *self); -gboolean gst_ah_camera_unlock (GstAHCamera *self); +void gst_ah_camera_set_preview_texture (GstAHCamera * self, + GstAGSurfaceTexture * surfaceTexture); +gboolean gst_ah_camera_start_preview (GstAHCamera * self); +gboolean gst_ah_camera_start_smooth_zoom (GstAHCamera * self, gint value); +gboolean gst_ah_camera_stop_preview (GstAHCamera * self); +gboolean gst_ah_camera_stop_smooth_zoom (GstAHCamera * self); +gboolean gst_ah_camera_unlock (GstAHCamera * self); /* android.hardware.Camera.Size */ GstAHCSize *gst_ahc_size_new (gint width, gint height); -void gst_ahc_size_free (GstAHCSize *self); +void gst_ahc_size_free (GstAHCSize * self); /* android.hardware.Camera.Parameters */ -gchar * gst_ahc_parameters_flatten (GstAHCParameters *self); -gint gst_ahc_parameters_get_preview_format (GstAHCParameters *self); -gboolean gst_ahc_parameters_get_preview_fps_range (GstAHCParameters *self, - gint *min, gint *max); -GstAHCSize *gst_ahc_parameters_get_preview_size (GstAHCParameters *self); +gchar *gst_ahc_parameters_flatten (GstAHCParameters * self); +const gchar *gst_ahc_parameters_get_antibanding (GstAHCParameters * self); +const gchar *gst_ahc_parameters_get_color_effect (GstAHCParameters * self); +gint gst_ahc_parameters_get_exposure_compensation (GstAHCParameters * self); +gfloat gst_ahc_parameters_get_exposure_compensation_step (GstAHCParameters + * self); +const gchar *gst_ahc_parameters_get_flash_mode (GstAHCParameters * self); +gfloat gst_ahc_parameters_get_focal_length (GstAHCParameters * self); +const gchar *gst_ahc_parameters_get_focus_mode (GstAHCParameters * self); +gfloat gst_ahc_parameters_get_horizontal_view_angle (GstAHCParameters * self); +gint gst_ahc_parameters_get_max_exposure_compensation (GstAHCParameters * self); +gint gst_ahc_parameters_get_max_zoom (GstAHCParameters * self); +gint gst_ahc_parameters_get_min_exposure_compensation (GstAHCParameters * self); +gint gst_ahc_parameters_get_preview_format (GstAHCParameters * self); +gboolean gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, + gint * min, gint * max); +GstAHCSize *gst_ahc_parameters_get_preview_size (GstAHCParameters * self); +const gchar *gst_ahc_parameters_get_scene_mode (GstAHCParameters * self); +/* GList */ +GList *gst_ahc_parameters_get_supported_antibanding (GstAHCParameters * self); +void gst_ahc_parameters_supported_antibanding_free (GList * list); +/* GList */ +GList *gst_ahc_parameters_get_supported_color_effects (GstAHCParameters * self); +void gst_ahc_parameters_supported_color_effects_free (GList * list); +/* GList */ +GList *gst_ahc_parameters_get_supported_flash_modes (GstAHCParameters * self); +void gst_ahc_parameters_supported_flash_modes_free (GList * list); +/* GList */ +GList *gst_ahc_parameters_get_supported_focus_modes (GstAHCParameters * self); +void gst_ahc_parameters_supported_focus_modes_free (GList * list); /* GList */ -GList *gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters *self); -void gst_ahc_parameters_supported_preview_formats_free (GList *list); +GList *gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters + * self); +void gst_ahc_parameters_supported_preview_formats_free (GList * list); /* GList */ -GList *gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters *self); -void gst_ahc_parameters_supported_preview_fps_range_free (GList *list); +GList *gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters + * self); +void gst_ahc_parameters_supported_preview_fps_range_free (GList * list); /* GList */ -GList *gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters *self); -void gst_ahc_parameters_supported_preview_sizes_free (GList *list); -gboolean gst_ahc_parameters_set_preview_format (GstAHCParameters *self, gint format); -gboolean gst_ahc_parameters_set_preview_fps_range (GstAHCParameters *self, +GList *gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self); +void gst_ahc_parameters_supported_preview_sizes_free (GList * list); +/* GList */ +GList *gst_ahc_parameters_get_supported_scene_modes (GstAHCParameters * self); +void gst_ahc_parameters_supported_scene_modes_free (GList * list); +/* GList */ +GList *gst_ahc_parameters_get_supported_white_balance (GstAHCParameters * self); +void gst_ahc_parameters_supported_white_balance_free (GList * list); +gfloat gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self); +const gchar *gst_ahc_parameters_get_white_balance (GstAHCParameters * self); +gint gst_ahc_parameters_get_zoom (GstAHCParameters * self); +/* GList */ +GList *gst_ahc_parameters_get_zoom_ratios (GstAHCParameters * self); +void gst_ahc_parameters_zoom_ratios_free (GList * list); +gboolean gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self); +gboolean gst_ahc_parameters_is_zoom_supported (GstAHCParameters * self); +gboolean gst_ahc_parameters_set_antibanding (GstAHCParameters * self, + const gchar * antibanding); +gboolean gst_ahc_parameters_set_color_effect (GstAHCParameters * self, + const gchar * value); +gboolean gst_ahc_parameters_set_exposure_compensation (GstAHCParameters * self, + gint value); +gboolean gst_ahc_parameters_set_flash_mode (GstAHCParameters * self, + const gchar * value); +gboolean gst_ahc_parameters_set_focus_mode (GstAHCParameters * self, + const gchar * value); +gboolean gst_ahc_parameters_set_preview_format (GstAHCParameters * self, + gint format); +gboolean gst_ahc_parameters_set_preview_fps_range (GstAHCParameters * self, gint min, gint max); -gboolean gst_ahc_parameters_set_preview_size (GstAHCParameters *self, +gboolean gst_ahc_parameters_set_preview_size (GstAHCParameters * self, gint width, gint height); -gboolean gst_ahc_parameters_unflatten (GstAHCParameters *self, gchar *flattened); -void gst_ahc_parameters_free (GstAHCParameters *self); +gboolean gst_ahc_parameters_set_scene_mode (GstAHCParameters * self, + const gchar * value); +gboolean gst_ahc_parameters_set_white_balance (GstAHCParameters * self, + const gchar * value); +gboolean gst_ahc_parameters_set_zoom (GstAHCParameters * self, gint value); +gboolean gst_ahc_parameters_unflatten (GstAHCParameters * self, + const gchar * flattened); +void gst_ahc_parameters_free (GstAHCParameters * self); #endif /* __GST_ANDROID_HARDWARE_CAMERA_H__ */ - From 2d45a878b4aea5c26ee74da9eacfe7bf39665426 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Thu, 1 Nov 2012 15:24:12 -0400 Subject: [PATCH 42/82] anroidcamera: Add support for the GstPhotography interface --- sys/androidcamera/gstahcsrc.c | 809 +++++++++++++++++++++++++++++++++- 1 file changed, 805 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 3933430221..118d9e12b0 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -23,24 +23,26 @@ # include "config.h" #endif +#define GST_USE_UNSTABLE_API #include #include +#include #include "gstahcsrc.h" #include "gst-dvm.h" -static void gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface - * iface); -static void gst_ahc_src_init_interfaces (GType type); - +/* GObject */ static void gst_ahc_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_ahc_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_ahc_src_dispose (GObject * object); +/* GstElement */ static GstStateChangeReturn gst_ahc_src_change_state (GstElement * element, GstStateChange transition); + +/* GstBaseSrc */ static GstCaps *gst_ahc_src_getcaps (GstBaseSrc * src); static gboolean gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps); static void gst_ahc_src_fixate (GstBaseSrc * basesrc, GstCaps * caps); @@ -51,6 +53,52 @@ static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); static gboolean gst_ahc_src_query (GstBaseSrc * bsrc, GstQuery * query); +/* GstPropertyProbe */ +static void gst_ahc_src_implements_interface_init (GstImplementsInterfaceClass + * klass); +static void gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface + * iface); +static void gst_ahc_src_photography_interface_init (GstPhotographyInterface + * iface); +static void gst_ahc_src_init_interfaces (GType type); + +/* GstPhotography */ +static gboolean gst_ahc_src_get_ev_compensation (GstPhotography * photo, + gfloat * ev_comp); +static gboolean gst_ahc_src_get_white_balance_mode (GstPhotography * photo, + GstWhiteBalanceMode * wb_mode); +static gboolean gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, + GstColourToneMode * tone_mode); +static gboolean gst_ahc_src_get_scene_mode (GstPhotography * photo, + GstSceneMode * scene_mode); +static gboolean gst_ahc_src_get_flash_mode (GstPhotography * photo, + GstFlashMode * flash_mode); +static gboolean gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom); +static gboolean gst_ahc_src_get_flicker_mode (GstPhotography * photo, + GstFlickerReductionMode * flicker_mode); +static gboolean gst_ahc_src_get_focus_mode (GstPhotography * photo, + GstFocusMode * focus_mode); + +static gboolean gst_ahc_src_set_ev_compensation (GstPhotography * photo, + gfloat ev_comp); +static gboolean gst_ahc_src_set_white_balance_mode (GstPhotography * photo, + GstWhiteBalanceMode wb_mode); +static gboolean gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, + GstColourToneMode tone_mode); +static gboolean gst_ahc_src_set_scene_mode (GstPhotography * photo, + GstSceneMode scene_mode); +static gboolean gst_ahc_src_set_flash_mode (GstPhotography * photo, + GstFlashMode flash_mode); +static gboolean gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom); +static gboolean gst_ahc_src_set_flicker_mode (GstPhotography * photo, + GstFlickerReductionMode flicker_mode); +static gboolean gst_ahc_src_set_focus_mode (GstPhotography * photo, + GstFocusMode focus_mode); + +static GstPhotoCaps gst_ahc_src_get_capabilities (GstPhotography * photo); +static void gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on); + +/* GstAHCSrc */ static void gst_ahc_src_close (GstAHCSrc * self); static void gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data); static void gst_ahc_src_on_error (int error, gpointer user_data); @@ -112,9 +160,23 @@ gst_ahc_src_init_interfaces (GType type) NULL, NULL, }; + static const GInterfaceInfo ahcsrc_photography_info = { + (GInterfaceInitFunc) gst_ahc_src_photography_interface_init, + NULL, + NULL, + }; + static const GInterfaceInfo ahcsrc_implements_interface_info = { + (GInterfaceInitFunc) gst_ahc_src_implements_interface_init, + NULL, + NULL, + }; g_type_add_interface_static (type, GST_TYPE_PROPERTY_PROBE, &ahcsrc_propertyprobe_info); + g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE, + &ahcsrc_implements_interface_info); + g_type_add_interface_static (type, GST_TYPE_PHOTOGRAPHY, + &ahcsrc_photography_info); } static void @@ -175,6 +237,8 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + /* TODO: override GstPhotography properties */ + klass->probe_properties = NULL; } @@ -275,6 +339,23 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } } +static gboolean +gst_ahc_src_interface_supported (GstImplementsInterface * iface, + GType iface_type) +{ + if (iface_type == GST_TYPE_PHOTOGRAPHY || + iface_type == GST_TYPE_PROPERTY_PROBE) + return TRUE; + else + return FALSE; +} + +static void +gst_ahc_src_implements_interface_init (GstImplementsInterfaceClass * klass) +{ + klass->supported = gst_ahc_src_interface_supported; +} + static const GList * gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) { @@ -325,6 +406,726 @@ gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface * iface) iface->get_values = gst_ahc_src_probe_get_values; } + +static gboolean +gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gint ev, min, max; + gfloat step; + + ev = gst_ahc_parameters_get_exposure_compensation (params); + min = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_min_exposure_compensation (params); + step = gst_ahc_parameters_get_exposure_compensation_step (params); + if (step != 0.0 && min != max && ev >= min && ev <= max && step != 0.0) { + if (ev_comp) + *ev_comp = ev * step; + ret = TRUE; + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_white_balance_mode (GstPhotography * photo, + GstWhiteBalanceMode * wb_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *wb = gst_ahc_parameters_get_white_balance (params); + GstWhiteBalanceMode mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; + + ret = TRUE; + if (wb == Parameters_WHITE_BALANCE_AUTO) + mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; + else if (wb == Parameters_WHITE_BALANCE_INCANDESCENT) + mode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN; + else if (wb == Parameters_WHITE_BALANCE_FLUORESCENT) + mode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT; + //else if (wb == Parameters_WHITE_BALANCE_WARM_FLUORESCENT) + else if (wb == Parameters_WHITE_BALANCE_DAYLIGHT) + mode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT; + else if (wb == Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT) + mode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY; + else if (wb == Parameters_WHITE_BALANCE_TWILIGHT) + mode = GST_PHOTOGRAPHY_WB_MODE_SUNSET; + //else if (wb == Parameters_WHITE_BALANCE_SHADE) + else + ret = FALSE; + + if (ret && wb_mode) + *wb_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, + GstColourToneMode * tone_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *effect = gst_ahc_parameters_get_color_effect (params); + GstColourToneMode mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; + + ret = TRUE; + if (effect == Parameters_EFFECT_NONE) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; + else if (effect == Parameters_EFFECT_MONO) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE; + else if (effect == Parameters_EFFECT_NEGATIVE) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE; + else if (effect == Parameters_EFFECT_SOLARIZE) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE; + else if (effect == Parameters_EFFECT_SEPIA) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA; + //else if (effect == Parameters_EFFECT_POSTERIZE) + //else if (effect == Parameters_EFFECT_WHITEBOARD) + //else if (effect == Parameters_EFFECT_BLACKBOARD) + //else if (effect == Parameters_EFFECT_AQUA) + else + ret = FALSE; + + if (ret && tone_mode) + *tone_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (scene_mode && self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *scene = gst_ahc_parameters_get_scene_mode (params); + GstSceneMode mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + + ret = TRUE; + if (scene == Parameters_SCENE_MODE_AUTO) + mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + //else if (scene == Parameters_SCENE_MODE_ACTION) + else if (scene == Parameters_SCENE_MODE_PORTRAIT) + mode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; + else if (scene == Parameters_SCENE_MODE_LANDSCAPE) + mode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; + else if (scene == Parameters_SCENE_MODE_NIGHT) + mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; + //else if (scene == Parameters_SCENE_MODE_NIGHT_PORTRAIT) + //else if (scene == Parameters_SCENE_MODE_THEATRE) + //else if (scene == Parameters_SCENE_MODE_BEACH) + //else if (scene == Parameters_SCENE_MODE_SNOW) + //else if (scene == Parameters_SCENE_MODE_SUNSET) + //else if (scene == Parameters_SCENE_MODE_STEADYPHOTO) + //else if (scene == Parameters_SCENE_MODE_FIREWORKS) + else if (scene == Parameters_SCENE_MODE_SPORTS) + mode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; + //else if (scene == Parameters_SCENE_MODE_PARTY) + //else if (scene == Parameters_SCENE_MODE_CANDLELIGHT) + //else if (scene == Parameters_SCENE_MODE_BARCODE) + else + ret = FALSE; + + if (ret && scene_mode) + *scene_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_flash_mode (GstPhotography * photo, GstFlashMode * flash_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *flash = gst_ahc_parameters_get_flash_mode (params); + GstFlashMode mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; + + ret = TRUE; + if (flash == Parameters_FLASH_MODE_OFF) + mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; + else if (flash == Parameters_FLASH_MODE_AUTO) + mode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO; + else if (flash == Parameters_FLASH_MODE_ON) + mode = GST_PHOTOGRAPHY_FLASH_MODE_ON; + else if (flash == Parameters_FLASH_MODE_RED_EYE) + mode = GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE; + else if (flash == Parameters_FLASH_MODE_TORCH) + mode = GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN; + else + ret = FALSE; + + if (ret && flash_mode) + *flash_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); + gint zoom_idx = gst_ahc_parameters_get_zoom (params); + gint max_zoom = gst_ahc_parameters_get_max_zoom (params); + + if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1) && + zoom_idx >= 0 && zoom_idx < max_zoom) { + gint zoom_value; + + zoom_value = GPOINTER_TO_INT (g_list_nth_data (zoom_ratios, zoom_idx)); + if (zoom) + *zoom = (gfloat) zoom_value / 100.0; + + ret = TRUE; + } + gst_ahc_parameters_zoom_ratios_free (zoom_ratios); + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_flicker_mode (GstPhotography * photo, + GstFlickerReductionMode * flicker_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *antibanding = gst_ahc_parameters_get_antibanding (params); + GstFlickerReductionMode mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; + + ret = TRUE; + if (antibanding == Parameters_ANTIBANDING_AUTO) + mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; + else if (antibanding == Parameters_ANTIBANDING_50HZ) + mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_50HZ; + else if (antibanding == Parameters_ANTIBANDING_60HZ) + mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_60HZ; + else if (antibanding == Parameters_ANTIBANDING_OFF) + mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF; + else + ret = FALSE; + + if (ret && flicker_mode) + *flicker_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *focus = gst_ahc_parameters_get_focus_mode (params); + GstFocusMode mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; + + ret = TRUE; + if (focus == Parameters_FOCUS_MODE_AUTO) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; + else if (focus == Parameters_FOCUS_MODE_INFINITY) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY; + else if (focus == Parameters_FOCUS_MODE_MACRO) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_MACRO; + //else if (focus == Parameters_FOCUS_MODE_FIXED) + else if (focus == Parameters_FOCUS_MODE_EDOF) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL; + else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_VIDEO) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED; + else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_PICTURE) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL; + else + ret = FALSE; + + if (ret && focus_mode) + *focus_mode = mode; + + gst_ahc_parameters_free (params); + } + } + + return ret; +} + + +static gboolean +gst_ahc_src_set_ev_compensation (GstPhotography * photo, gfloat ev_comp) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gint ev, min, max; + gfloat step; + + ev = gst_ahc_parameters_get_exposure_compensation (params); + min = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_min_exposure_compensation (params); + step = gst_ahc_parameters_get_exposure_compensation_step (params); + if (step != 0.0 && min != max && step != 0.0 && + ev_comp >= min && ev_comp <= max) { + /* TODO: error or get closest ev? */ + ev = ev_comp / step; + if ((ev * step) == ev_comp) { + gst_ahc_parameters_set_exposure_compensation (params, ev); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + } + } + gst_ahc_parameters_free (params); + } + + return ret; +} + +static gboolean +gst_ahc_src_set_white_balance_mode (GstPhotography * photo, + GstWhiteBalanceMode wb_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *white_balance = NULL; + + switch (wb_mode) { + case GST_PHOTOGRAPHY_WB_MODE_AUTO: + white_balance = Parameters_WHITE_BALANCE_AUTO; + break; + case GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT: + white_balance = Parameters_WHITE_BALANCE_DAYLIGHT; + break; + case GST_PHOTOGRAPHY_WB_MODE_CLOUDY: + white_balance = Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT; + break; + case GST_PHOTOGRAPHY_WB_MODE_SUNSET: + white_balance = Parameters_WHITE_BALANCE_TWILIGHT; + break; + case GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN: + white_balance = Parameters_WHITE_BALANCE_INCANDESCENT; + break; + case GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT: + white_balance = Parameters_WHITE_BALANCE_FLUORESCENT; + break; + default: + white_balance = NULL; + break; + } + + if (white_balance) { + gst_ahc_parameters_set_white_balance (params, white_balance); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, + GstColourToneMode tone_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *color_effect = NULL; + + switch (tone_mode) { + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL: + color_effect = Parameters_EFFECT_NONE; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA: + color_effect = Parameters_EFFECT_SEPIA; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE: + color_effect = Parameters_EFFECT_NEGATIVE; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE: + color_effect = Parameters_EFFECT_MONO; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE: + color_effect = Parameters_EFFECT_SOLARIZE; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NATURAL: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_VIVID: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_COLORSWAP: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_OUT_OF_FOCUS: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SKY_BLUE: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRASS_GREEN: + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SKIN_WHITEN: + default: + color_effect = NULL; + break; + } + + if (color_effect) { + gst_ahc_parameters_set_color_effect (params, color_effect); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_scene_mode (GstPhotography * photo, GstSceneMode scene_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *scene = NULL; + + switch (scene_mode) { + case GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT: + scene = Parameters_SCENE_MODE_PORTRAIT; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE: + scene = Parameters_SCENE_MODE_LANDSCAPE; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_SPORT: + scene = Parameters_SCENE_MODE_SPORTS; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_NIGHT: + scene = Parameters_SCENE_MODE_NIGHT; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_AUTO: + scene = Parameters_SCENE_MODE_AUTO; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_MANUAL: + case GST_PHOTOGRAPHY_SCENE_MODE_CLOSEUP: + default: + scene = NULL; + break; + } + + if (scene) { + gst_ahc_parameters_set_scene_mode (params, scene); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_flash_mode (GstPhotography * photo, GstFlashMode flash_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *flash = NULL; + + switch (flash_mode) { + case GST_PHOTOGRAPHY_FLASH_MODE_AUTO: + flash = Parameters_FLASH_MODE_AUTO; + break; + case GST_PHOTOGRAPHY_FLASH_MODE_OFF: + flash = Parameters_FLASH_MODE_OFF; + break; + case GST_PHOTOGRAPHY_FLASH_MODE_ON: + flash = Parameters_FLASH_MODE_ON; + break; + case GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN: + flash = Parameters_FLASH_MODE_TORCH; + break; + case GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE: + flash = Parameters_FLASH_MODE_RED_EYE; + break; + default: + flash = NULL; + break; + } + + if (flash) { + gst_ahc_parameters_set_flash_mode (params, flash); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); + gint max_zoom = gst_ahc_parameters_get_max_zoom (params); + gint zoom_idx = -1; + + if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { + gint i; + + for (i = 0; i < max_zoom + 1; i++) { + gint zoom_value = GPOINTER_TO_INT (g_list_nth_data (zoom_ratios, i)); + gfloat value = (gfloat) zoom_value / 100.0; + + /* TODO: error or get closest zoom? */ + if (value == zoom) + zoom_idx = i; + } + } + if (zoom_idx != -1) { + gst_ahc_parameters_set_zoom (params, zoom_idx); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_flicker_mode (GstPhotography * photo, + GstFlickerReductionMode flicker_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *antibanding = NULL; + + switch (flicker_mode) { + case GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF: + antibanding = Parameters_ANTIBANDING_OFF; + break; + case GST_PHOTOGRAPHY_FLICKER_REDUCTION_50HZ: + antibanding = Parameters_ANTIBANDING_50HZ; + break; + case GST_PHOTOGRAPHY_FLICKER_REDUCTION_60HZ: + antibanding = Parameters_ANTIBANDING_60HZ; + break; + case GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO: + antibanding = Parameters_ANTIBANDING_AUTO; + break; + default: + antibanding = NULL; + break; + } + + if (antibanding) { + gst_ahc_parameters_set_antibanding (params, antibanding); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static gboolean +gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + gboolean ret = FALSE; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + const gchar *focus = NULL; + + switch (focus_mode) { + case GST_PHOTOGRAPHY_FOCUS_MODE_AUTO: + focus = Parameters_FOCUS_MODE_AUTO; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_MACRO: + focus = Parameters_FOCUS_MODE_MACRO; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY: + focus = Parameters_FOCUS_MODE_INFINITY; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL: + focus = Parameters_FOCUS_MODE_EDOF; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL: + focus = Parameters_FOCUS_MODE_CONTINUOUS_PICTURE; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED: + focus = Parameters_FOCUS_MODE_CONTINUOUS_VIDEO; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_PORTRAIT: + case GST_PHOTOGRAPHY_FOCUS_MODE_EXTENDED: + default: + focus = NULL; + break; + } + + if (focus) { + gst_ahc_parameters_set_focus_mode (params, focus); + ret = gst_ah_camera_set_parameters (self->camera, params); + } + gst_ahc_parameters_free (params); + } + } + + return ret; +} + +static GstPhotoCaps +gst_ahc_src_get_capabilities (GstPhotography * photo) +{ + return GST_PHOTOGRAPHY_CAPS_EV_COMP | GST_PHOTOGRAPHY_CAPS_WB_MODE | + GST_PHOTOGRAPHY_CAPS_TONE | GST_PHOTOGRAPHY_CAPS_SCENE | + GST_PHOTOGRAPHY_CAPS_FLASH | GST_PHOTOGRAPHY_CAPS_ZOOM | + GST_PHOTOGRAPHY_CAPS_FOCUS; +} + +static void +gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on) +{ + GstAHCSrc *self = GST_AHC_SRC (photo); + + if (self->camera) { + /* TODO: Call the autofocus and signal when callback is called */ + } + +} + +static void +gst_ahc_src_photography_interface_init (GstPhotographyInterface * iface) +{ + iface->get_ev_compensation = gst_ahc_src_get_ev_compensation; + iface->get_white_balance_mode = gst_ahc_src_get_white_balance_mode; + iface->get_colour_tone_mode = gst_ahc_src_get_colour_tone_mode; + iface->get_scene_mode = gst_ahc_src_get_scene_mode; + iface->get_flash_mode = gst_ahc_src_get_flash_mode; + iface->get_zoom = gst_ahc_src_get_zoom; + iface->get_flicker_mode = gst_ahc_src_get_flicker_mode; + iface->get_focus_mode = gst_ahc_src_get_focus_mode; + + iface->set_ev_compensation = gst_ahc_src_set_ev_compensation; + iface->set_white_balance_mode = gst_ahc_src_set_white_balance_mode; + iface->set_colour_tone_mode = gst_ahc_src_set_colour_tone_mode; + iface->set_scene_mode = gst_ahc_src_set_scene_mode; + iface->set_flash_mode = gst_ahc_src_set_flash_mode; + iface->set_zoom = gst_ahc_src_set_zoom; + iface->set_flicker_mode = gst_ahc_src_set_flicker_mode; + iface->set_focus_mode = gst_ahc_src_set_focus_mode; + + iface->get_capabilities = gst_ahc_src_get_capabilities; + iface->set_autofocus = gst_ahc_src_set_autofocus; +} + static gint _compare_formats (int f1, int f2) { From 24b29d42666ba0ae37f5ac1d1fae979c70a3255e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 2 Nov 2012 16:59:42 -0400 Subject: [PATCH 43/82] androidcamera: Override properties --- sys/androidcamera/gstahcsrc.c | 174 +++++++++++++++++++++++++++++++++- 1 file changed, 173 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 118d9e12b0..121a74612a 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -124,6 +124,21 @@ enum PROP_DEVICE, PROP_DEVICE_FACING, PROP_DEVICE_ORIENTATION, + PROP_WB_MODE, + PROP_COLOUR_TONE, + PROP_SCENE_MODE, + PROP_FLASH_MODE, + PROP_NOISE_REDUCTION, + PROP_CAPABILITIES, + PROP_EV_COMP, + PROP_ISO_SPEED, + PROP_APERTURE, + PROP_EXPOSURE, + PROP_IMAGE_CAPTURE_SUPPORTED_CAPS, + PROP_IMAGE_PREVIEW_SUPPORTED_CAPS, + PROP_FLICKER_MODE, + PROP_FOCUS_MODE, + PROP_ZOOM, }; #define DEFAULT_DEVICE "0" @@ -237,7 +252,39 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); - /* TODO: override GstPhotography properties */ + /* Override GstPhotography properties */ + g_object_class_override_property (gobject_class, PROP_WB_MODE, + GST_PHOTOGRAPHY_PROP_WB_MODE); + g_object_class_override_property (gobject_class, PROP_COLOUR_TONE, + GST_PHOTOGRAPHY_PROP_COLOUR_TONE); + g_object_class_override_property (gobject_class, PROP_SCENE_MODE, + GST_PHOTOGRAPHY_PROP_SCENE_MODE); + g_object_class_override_property (gobject_class, PROP_FLASH_MODE, + GST_PHOTOGRAPHY_PROP_FLASH_MODE); + g_object_class_override_property (gobject_class, PROP_NOISE_REDUCTION, + GST_PHOTOGRAPHY_PROP_NOISE_REDUCTION); + g_object_class_override_property (gobject_class, PROP_CAPABILITIES, + GST_PHOTOGRAPHY_PROP_CAPABILITIES); + g_object_class_override_property (gobject_class, PROP_EV_COMP, + GST_PHOTOGRAPHY_PROP_EV_COMP); + g_object_class_override_property (gobject_class, PROP_ISO_SPEED, + GST_PHOTOGRAPHY_PROP_ISO_SPEED); + g_object_class_override_property (gobject_class, PROP_APERTURE, + GST_PHOTOGRAPHY_PROP_APERTURE); + g_object_class_override_property (gobject_class, PROP_EXPOSURE, + GST_PHOTOGRAPHY_PROP_EXPOSURE); + g_object_class_override_property (gobject_class, + PROP_IMAGE_CAPTURE_SUPPORTED_CAPS, + GST_PHOTOGRAPHY_PROP_IMAGE_CAPTURE_SUPPORTED_CAPS); + g_object_class_override_property (gobject_class, + PROP_IMAGE_PREVIEW_SUPPORTED_CAPS, + GST_PHOTOGRAPHY_PROP_IMAGE_PREVIEW_SUPPORTED_CAPS); + g_object_class_override_property (gobject_class, PROP_FLICKER_MODE, + GST_PHOTOGRAPHY_PROP_FLICKER_MODE); + g_object_class_override_property (gobject_class, PROP_FOCUS_MODE, + GST_PHOTOGRAPHY_PROP_FOCUS_MODE); + g_object_class_override_property (gobject_class, PROP_ZOOM, + GST_PHOTOGRAPHY_PROP_ZOOM); klass->probe_properties = NULL; } @@ -294,6 +341,61 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, self->device = (gint) device; } break; + case PROP_WB_MODE:{ + GstWhiteBalanceMode wb = g_value_get_enum (value); + + gst_ahc_src_set_white_balance_mode (GST_PHOTOGRAPHY (self), wb); + } + break; + case PROP_COLOUR_TONE:{ + GstColourToneMode tone = g_value_get_enum (value); + + gst_ahc_src_set_colour_tone_mode (GST_PHOTOGRAPHY (self), tone); + } + break; + case PROP_SCENE_MODE:{ + GstSceneMode scene = g_value_get_enum (value); + + gst_ahc_src_set_scene_mode (GST_PHOTOGRAPHY (self), scene); + } + break; + case PROP_FLASH_MODE:{ + GstFlashMode flash = g_value_get_enum (value); + + gst_ahc_src_set_flash_mode (GST_PHOTOGRAPHY (self), flash); + } + break; + case PROP_EV_COMP:{ + gfloat ev = g_value_get_float (value); + + gst_ahc_src_set_ev_compensation (GST_PHOTOGRAPHY (self), ev); + } + break; + case PROP_FLICKER_MODE:{ + GstFlickerReductionMode flicker = g_value_get_enum (value); + + gst_ahc_src_set_flicker_mode (GST_PHOTOGRAPHY (self), flicker); + } + break; + case PROP_FOCUS_MODE:{ + GstFocusMode focus = g_value_get_enum (value); + + gst_ahc_src_set_focus_mode (GST_PHOTOGRAPHY (self), focus); + } + break; + case PROP_ZOOM:{ + gfloat zoom = g_value_get_float (value); + + gst_ahc_src_set_zoom (GST_PHOTOGRAPHY (self), zoom); + } + break; + case PROP_NOISE_REDUCTION: + case PROP_ISO_SPEED: + case PROP_APERTURE: + case PROP_EXPOSURE: + case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: + case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -333,6 +435,76 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, g_value_set_int (value, 0); } break; + case PROP_WB_MODE:{ + GstWhiteBalanceMode wb; + + if (gst_ahc_src_get_white_balance_mode (GST_PHOTOGRAPHY (self), &wb)) + g_value_set_enum (value, wb); + } + break; + case PROP_COLOUR_TONE:{ + GstColourToneMode tone; + + if (gst_ahc_src_get_colour_tone_mode (GST_PHOTOGRAPHY (self), &tone)) + g_value_set_enum (value, tone); + } + break; + case PROP_SCENE_MODE:{ + GstSceneMode scene; + + if (gst_ahc_src_get_scene_mode (GST_PHOTOGRAPHY (self), &scene)) + g_value_set_enum (value, scene); + } + break; + case PROP_FLASH_MODE:{ + GstFlashMode flash; + + if (gst_ahc_src_get_flash_mode (GST_PHOTOGRAPHY (self), &flash)) + g_value_set_enum (value, flash); + } + break; + case PROP_CAPABILITIES:{ + GstPhotoCaps caps; + + caps = gst_ahc_src_get_capabilities (GST_PHOTOGRAPHY (self)); + g_value_set_ulong (value, caps); + } + break; + case PROP_EV_COMP:{ + gfloat ev; + + if (gst_ahc_src_get_ev_compensation (GST_PHOTOGRAPHY (self), &ev)) + g_value_set_float (value, ev); + } + break; + case PROP_FLICKER_MODE:{ + GstFlickerReductionMode flicker; + + if (gst_ahc_src_get_flicker_mode (GST_PHOTOGRAPHY (self), &flicker)) + g_value_set_enum (value, flicker); + } + break; + case PROP_FOCUS_MODE:{ + GstFocusMode focus; + + if (gst_ahc_src_get_focus_mode (GST_PHOTOGRAPHY (self), &focus)) + g_value_set_enum (value, focus); + } + break; + case PROP_ZOOM:{ + gfloat zoom; + + if (gst_ahc_src_get_zoom (GST_PHOTOGRAPHY (self), &zoom)) + g_value_set_float (value, zoom); + } + break; + case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: + case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: + case PROP_NOISE_REDUCTION: + case PROP_ISO_SPEED: + case PROP_APERTURE: + case PROP_EXPOSURE: + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; From 1ef65636d19bded95c5d126af3840d937ad141b2 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 2 Nov 2012 17:00:45 -0400 Subject: [PATCH 44/82] androidcamera: Add autofocus support --- .../com/gstreamer/GstAhcCallback.java | 11 +++- .../gst-android-hardware-camera.c | 59 ++++++++++++++++++- .../gst-android-hardware-camera.h | 6 ++ sys/androidcamera/gstahcsrc.c | 21 ++++++- 4 files changed, 92 insertions(+), 5 deletions(-) diff --git a/sys/androidcamera/com/gstreamer/GstAhcCallback.java b/sys/androidcamera/com/gstreamer/GstAhcCallback.java index 45ce0e8550..0763d91f6e 100644 --- a/sys/androidcamera/com/gstreamer/GstAhcCallback.java +++ b/sys/androidcamera/com/gstreamer/GstAhcCallback.java @@ -2,7 +2,9 @@ package com.gstreamer; import android.hardware.Camera; -public class GstAhcCallback implements Camera.PreviewCallback, Camera.ErrorCallback { +public class GstAhcCallback implements Camera.PreviewCallback, + Camera.ErrorCallback, + Camera.AutoFocusCallback { public long mUserData; public long mCallback; @@ -10,6 +12,8 @@ public class GstAhcCallback implements Camera.PreviewCallback, Camera.ErrorCallb long callback, long user_data); public static native void gst_ah_camera_on_error(int error, Camera camera, long callback, long user_data); + public static native void gst_ah_camera_on_auto_focus(boolean success, Camera camera, + long callback, long user_data); public GstAhcCallback(long callback, long user_data) { mCallback = callback; @@ -25,4 +29,9 @@ public class GstAhcCallback implements Camera.PreviewCallback, Camera.ErrorCallb public void onError(int error, Camera camera) { gst_ah_camera_on_error(error, camera, mCallback, mUserData); } + + @Override + public void onAutoFocus(boolean success, Camera camera) { + gst_ah_camera_on_auto_focus(success, camera, mCallback, mUserData); + } } diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 53d09e46e5..7578c847df 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -32,6 +32,8 @@ static struct { jclass klass; jmethodID addCallbackBuffer; + jmethodID autoFocus; + jmethodID cancelAutoFocus; jmethodID getCameraInfo; jmethodID getNumberOfCameras; jmethodID getParameters; @@ -277,11 +279,23 @@ gst_ah_camera_on_error (JNIEnv * env, jclass klass, jint error, cb (error, (gpointer) (gsize) user_data); } +static void +gst_ah_camera_on_auto_focus (JNIEnv * env, jclass klass, jboolean success, + jobject camera, jlong callback, jlong user_data) +{ + GstAHCAutoFocusCallback cb = (GstAHCAutoFocusCallback) (gsize) callback; + + if (cb) + cb (success, (gpointer) (gsize) user_data); +} + static JNINativeMethod native_methods[] = { {"gst_ah_camera_on_preview_frame", "([BLandroid/hardware/Camera;JJ)V", (void *) gst_ah_camera_on_preview_frame}, {"gst_ah_camera_on_error", "(ILandroid/hardware/Camera;JJ)V", - (void *) gst_ah_camera_on_error} + (void *) gst_ah_camera_on_error}, + {"gst_ah_camera_on_auto_focus", "(ZLandroid/hardware/Camera;JJ)V", + (void *) gst_ah_camera_on_auto_focus} }; static gboolean @@ -292,6 +306,9 @@ _init_classes (void) /* android.hardware.Camera */ GST_DVM_GET_CLASS (android_hardware_camera, "android/hardware/Camera"); GST_DVM_GET_METHOD (android_hardware_camera, addCallbackBuffer, "([B)V"); + GST_DVM_GET_METHOD (android_hardware_camera, autoFocus, + "(Landroid/hardware/Camera$AutoFocusCallback;)V"); + GST_DVM_GET_METHOD (android_hardware_camera, cancelAutoFocus, "()V"); GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getCameraInfo, "(ILandroid/hardware/Camera$CameraInfo;)V"); GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getNumberOfCameras, @@ -1654,6 +1671,46 @@ gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer) AHC_CALL (, Void, addCallbackBuffer, buffer); } +gboolean +gst_ah_camera_auto_focus (GstAHCamera * self, + GstAHCAutoFocusCallback cb, gpointer user_data) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object = NULL; + gboolean ret = FALSE; + + if (cb) { + object = (*env)->NewObject (env, + com_gstreamer_gstahccallback.klass, + com_gstreamer_gstahccallback.constructor, + *((jlong *) & cb), *((jlong *) & user_data)); + if (!object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + goto done; + } + } + + AHC_CALL (goto done, Void, autoFocus, object); + + ret = TRUE; +done: + if (object) + (*env)->DeleteLocalRef (env, object); + + return ret; +} + +gboolean +gst_ah_camera_cancel_auto_focus (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + AHC_CALL (return FALSE, Void, cancelAutoFocus); + + return TRUE; +} + gboolean gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) { diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index d4246bc480..6ce80337c3 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -118,11 +118,17 @@ typedef void (*GstAHCErrorCallback) (gint error, gpointer user_data); /* android.hardware.Camera.PreviewCallback */ typedef void (*GstAHCPreviewCallback) (jbyteArray data, gpointer user_data); +/* android.hardware.Camera.AutoFocusCallback */ +typedef void (*GstAHCAutoFocusCallback) (gboolean success, gpointer user_data); + gboolean gst_android_hardware_camera_init (void); void gst_android_hardware_camera_deinit (void); /* android.hardware.Camera */ void gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer); +gboolean gst_ah_camera_auto_focus (GstAHCamera * self, + GstAHCAutoFocusCallback cb, gpointer user_data); +gboolean gst_ah_camera_cancel_auto_focus (GstAHCamera * self); gboolean gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info); gint gst_ah_camera_get_number_of_cameras (void); diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 121a74612a..12d44efd6b 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -101,7 +101,8 @@ static void gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on); /* GstAHCSrc */ static void gst_ahc_src_close (GstAHCSrc * self); static void gst_ahc_src_on_preview_frame (jbyteArray data, gpointer user_data); -static void gst_ahc_src_on_error (int error, gpointer user_data); +static void gst_ahc_src_on_error (gint error, gpointer user_data); +static void gst_ahc_src_on_auto_focus (gboolean success, gpointer user_data); #define NUM_CALLBACK_BUFFERS 5 @@ -1262,13 +1263,27 @@ gst_ahc_src_get_capabilities (GstPhotography * photo) GST_PHOTOGRAPHY_CAPS_FOCUS; } +static void +gst_ahc_src_on_auto_focus (gboolean success, gpointer user_data) +{ + GstAHCSrc *self = GST_AHC_SRC (user_data); + + GST_WARNING_OBJECT (self, "Auto focus completed : %d", success); + gst_element_post_message (GST_ELEMENT (self), + gst_message_new_custom (GST_MESSAGE_ELEMENT, GST_OBJECT (self), + gst_structure_new (GST_PHOTOGRAPHY_AUTOFOCUS_DONE, NULL))); +} + static void gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on) { GstAHCSrc *self = GST_AHC_SRC (photo); if (self->camera) { - /* TODO: Call the autofocus and signal when callback is called */ + if (on) + gst_ah_camera_auto_focus (self->camera, gst_ahc_src_on_auto_focus, self); + else + gst_ah_camera_cancel_auto_focus (self->camera); } } @@ -1700,7 +1715,7 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) } static void -gst_ahc_src_on_error (int error, gpointer user_data) +gst_ahc_src_on_error (gint error, gpointer user_data) { GstAHCSrc *self = GST_AHC_SRC (user_data); From 49a40edae97ef4b8cb19c73523a0341fe361a217 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 2 Nov 2012 18:00:55 -0400 Subject: [PATCH 45/82] androidmedia: Implement property probe for zoom and ev_compensation --- sys/androidcamera/gstahcsrc.c | 82 +++++++++++++++++++++++++++++++---- 1 file changed, 74 insertions(+), 8 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 12d44efd6b..099a9aeea3 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -535,10 +535,17 @@ gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) GObjectClass *klass = G_OBJECT_GET_CLASS (probe); GstAHCSrcClass *ahc_class = GST_AHC_SRC_CLASS (probe); - - if (!ahc_class->probe_properties) + /* FIXME: g_object_class_find_property returns overriden property with + * param_id == 0, so we can't switch/case the prop_id and + * g_param_spec_get_redirect_target() returns NULL */ + if (!ahc_class->probe_properties) { ahc_class->probe_properties = g_list_append (NULL, g_object_class_find_property (klass, "device")); + ahc_class->probe_properties = g_list_append (ahc_class->probe_properties, + g_object_class_find_property (klass, GST_PHOTOGRAPHY_PROP_EV_COMP)); + ahc_class->probe_properties = g_list_append (ahc_class->probe_properties, + g_object_class_find_property (klass, GST_PHOTOGRAPHY_PROP_ZOOM)); + } return ahc_class->probe_properties; } @@ -547,6 +554,7 @@ static GValueArray * gst_ahc_src_probe_get_values (GstPropertyProbe * probe, guint prop_id, const GParamSpec * pspec) { + GstAHCSrc *self = GST_AHC_SRC (probe); GValueArray *array = NULL; switch (prop_id) { @@ -564,6 +572,66 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, g_value_unset (&value); } break; + case PROP_EV_COMP: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gint min, max; + gfloat step, ev; + + min = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_max_exposure_compensation (params); + step = gst_ahc_parameters_get_exposure_compensation_step (params); + + if (step != 0.0 && min != max) { + GValue value = { 0 }; + gint i, total = 0; + + total = (max - min) / step; + + array = g_value_array_new (total); + g_value_init (&value, G_TYPE_FLOAT); + for (i = 0, ev = min; i < total && ev < max; i++, ev += step) { + g_value_set_float (&value, ev); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + + gst_ahc_parameters_free (params); + } + } + break; + case PROP_ZOOM: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); + gint max_zoom = gst_ahc_parameters_get_max_zoom (params); + + if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { + GValue value = { 0 }; + GList *i; + + array = g_value_array_new (max_zoom + 1); + g_value_init (&value, G_TYPE_FLOAT); + for (i = zoom_ratios; i; i = i->next) { + gint zoom_value = GPOINTER_TO_INT (i->data); + gfloat zoom = (gfloat) zoom_value / 100.0; + + g_value_set_float (&value, zoom); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + gst_ahc_parameters_free (params); + } + } + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); break; @@ -596,9 +664,10 @@ gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp) ev = gst_ahc_parameters_get_exposure_compensation (params); min = gst_ahc_parameters_get_min_exposure_compensation (params); - max = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_max_exposure_compensation (params); step = gst_ahc_parameters_get_exposure_compensation_step (params); - if (step != 0.0 && min != max && ev >= min && ev <= max && step != 0.0) { + + if (step != 0.0 && min != max && ev >= min && ev <= max) { if (ev_comp) *ev_comp = ev * step; ret = TRUE; @@ -913,9 +982,7 @@ gst_ahc_src_set_ev_compensation (GstPhotography * photo, gfloat ev_comp) min = gst_ahc_parameters_get_min_exposure_compensation (params); max = gst_ahc_parameters_get_min_exposure_compensation (params); step = gst_ahc_parameters_get_exposure_compensation_step (params); - if (step != 0.0 && min != max && step != 0.0 && - ev_comp >= min && ev_comp <= max) { - /* TODO: error or get closest ev? */ + if (step != 0.0 && min != max && ev_comp >= min && ev_comp <= max) { ev = ev_comp / step; if ((ev * step) == ev_comp) { gst_ahc_parameters_set_exposure_compensation (params, ev); @@ -1145,7 +1212,6 @@ gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) gint zoom_value = GPOINTER_TO_INT (g_list_nth_data (zoom_ratios, i)); gfloat value = (gfloat) zoom_value / 100.0; - /* TODO: error or get closest zoom? */ if (value == zoom) zoom_idx = i; } From dae0337d910002ca291caf21e61a33dce0fc6439 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 2 Nov 2012 18:07:24 -0400 Subject: [PATCH 46/82] androidcamera: Use strcmp on the GParamSpec property name Use strcmp instead of using the property_id because it's overriden --- sys/androidcamera/gstahcsrc.c | 131 +++++++++++++++++----------------- 1 file changed, 67 insertions(+), 64 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 099a9aeea3..912008b58d 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -535,9 +535,6 @@ gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) GObjectClass *klass = G_OBJECT_GET_CLASS (probe); GstAHCSrcClass *ahc_class = GST_AHC_SRC_CLASS (probe); - /* FIXME: g_object_class_find_property returns overriden property with - * param_id == 0, so we can't switch/case the prop_id and - * g_param_spec_get_redirect_target() returns NULL */ if (!ahc_class->probe_properties) { ahc_class->probe_properties = g_list_append (NULL, g_object_class_find_property (klass, "device")); @@ -572,68 +569,74 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, g_value_unset (&value); } break; - case PROP_EV_COMP: - if (self->camera) { - GstAHCParameters *params; - - params = gst_ah_camera_get_parameters (self->camera); - if (params) { - gint min, max; - gfloat step, ev; - - min = gst_ahc_parameters_get_min_exposure_compensation (params); - max = gst_ahc_parameters_get_max_exposure_compensation (params); - step = gst_ahc_parameters_get_exposure_compensation_step (params); - - if (step != 0.0 && min != max) { - GValue value = { 0 }; - gint i, total = 0; - - total = (max - min) / step; - - array = g_value_array_new (total); - g_value_init (&value, G_TYPE_FLOAT); - for (i = 0, ev = min; i < total && ev < max; i++, ev += step) { - g_value_set_float (&value, ev); - g_value_array_append (array, &value); - } - g_value_unset (&value); - } - - gst_ahc_parameters_free (params); - } - } - break; - case PROP_ZOOM: - if (self->camera) { - GstAHCParameters *params; - - params = gst_ah_camera_get_parameters (self->camera); - if (params) { - GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); - gint max_zoom = gst_ahc_parameters_get_max_zoom (params); - - if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { - GValue value = { 0 }; - GList *i; - - array = g_value_array_new (max_zoom + 1); - g_value_init (&value, G_TYPE_FLOAT); - for (i = zoom_ratios; i; i = i->next) { - gint zoom_value = GPOINTER_TO_INT (i->data); - gfloat zoom = (gfloat) zoom_value / 100.0; - - g_value_set_float (&value, zoom); - g_value_array_append (array, &value); - } - g_value_unset (&value); - } - gst_ahc_parameters_free (params); - } - } - break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + /* g_object_class_find_property returns overriden property with + * param_id == 0, so we can't switch/case the prop_id and + * g_param_spec_get_redirect_target() returns NULL, so we need to + * do a strcmp on the property's name instead */ + if (!g_strcmp0 (pspec->name, GST_PHOTOGRAPHY_PROP_EV_COMP)) { + //case PROP_EV_COMP: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gint min, max; + gfloat step, ev; + + min = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_max_exposure_compensation (params); + step = gst_ahc_parameters_get_exposure_compensation_step (params); + + if (step != 0.0 && min != max) { + GValue value = { 0 }; + gint i, total = 0; + + total = (max - min) / step; + + array = g_value_array_new (total); + g_value_init (&value, G_TYPE_FLOAT); + for (i = 0, ev = min; i < total && ev < max; i++, ev += step) { + g_value_set_float (&value, ev); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + + gst_ahc_parameters_free (params); + } + } + } else if (!g_strcmp0 (pspec->name, GST_PHOTOGRAPHY_PROP_ZOOM)) { + //case PROP_ZOOM: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); + gint max_zoom = gst_ahc_parameters_get_max_zoom (params); + + if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { + GValue value = { 0 }; + GList *i; + + array = g_value_array_new (max_zoom + 1); + g_value_init (&value, G_TYPE_FLOAT); + for (i = zoom_ratios; i; i = i->next) { + gint zoom_value = GPOINTER_TO_INT (i->data); + gfloat zoom = (gfloat) zoom_value / 100.0; + + g_value_set_float (&value, zoom); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + gst_ahc_parameters_free (params); + } + } + } else { + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + } break; } From 39d77294767595485313b8014720989d4c3d8967 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 7 Nov 2012 15:37:43 -0500 Subject: [PATCH 47/82] androidcamera: Be NULL-safe when a JNI list is returned --- .../gst-android-hardware-camera.c | 260 ++++++++++-------- 1 file changed, 145 insertions(+), 115 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 7578c847df..2352e93c86 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -2680,26 +2680,29 @@ gst_ahc_parameters_get_supported_antibanding (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedAntibanding); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _antibanding_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _antibanding_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2715,26 +2718,29 @@ gst_ahc_parameters_get_supported_color_effects (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedColorEffects); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _color_effect_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _color_effect_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2750,26 +2756,29 @@ gst_ahc_parameters_get_supported_flash_modes (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedFlashModes); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _flash_mode_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _flash_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2785,26 +2794,29 @@ gst_ahc_parameters_get_supported_focus_modes (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedFocusModes); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _focus_mode_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _focus_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2820,26 +2832,29 @@ gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedPreviewFormats); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject integer = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (integer) { - jint value = java_lang_integer_int_value (env, integer); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject integer = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, GINT_TO_POINTER (value)); - (*env)->DeleteLocalRef (env, integer); + if (integer) { + jint value = java_lang_integer_int_value (env, integer); + + ret = g_list_append (ret, GINT_TO_POINTER (value)); + (*env)->DeleteLocalRef (env, integer); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2855,27 +2870,30 @@ gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedPreviewFpsRange); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jintArray range = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (range) { - jint *fps = malloc (sizeof (jint) * 2); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jintArray range = java_util_iterator_next (env, iterator); - (*env)->GetIntArrayRegion (env, range, 0, 2, fps); - ret = g_list_append (ret, fps); - (*env)->DeleteLocalRef (env, range); + if (range) { + jint *fps = malloc (sizeof (jint) * 2); + + (*env)->GetIntArrayRegion (env, range, 0, 2, fps); + ret = g_list_append (ret, fps); + (*env)->DeleteLocalRef (env, range); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2891,31 +2909,34 @@ gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedPreviewSizes); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject jsize = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (jsize) { - jint width, height; + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject jsize = java_util_iterator_next (env, iterator); - width = (*env)->GetIntField (env, jsize, - android_hardware_camera_size.width); - height = (*env)->GetIntField (env, jsize, - android_hardware_camera_size.height); + if (jsize) { + jint width, height; - ret = g_list_append (ret, gst_ahc_size_new (width, height)); - (*env)->DeleteLocalRef (env, jsize); + width = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.width); + height = (*env)->GetIntField (env, jsize, + android_hardware_camera_size.height); + + ret = g_list_append (ret, gst_ahc_size_new (width, height)); + (*env)->DeleteLocalRef (env, jsize); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2931,26 +2952,29 @@ gst_ahc_parameters_get_supported_scene_modes (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedSceneModes); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _scene_mode_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _scene_mode_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -2966,26 +2990,29 @@ gst_ahc_parameters_get_supported_white_balance (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getSupportedWhiteBalance); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject str = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (str) { - const gchar *value = _white_balance_to_gchar (env, str); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject str = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, (gchar *) value); - (*env)->DeleteLocalRef (env, str); + if (str) { + const gchar *value = _white_balance_to_gchar (env, str); + + ret = g_list_append (ret, (gchar *) value); + (*env)->DeleteLocalRef (env, str); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } @@ -3040,26 +3067,29 @@ gst_ahc_parameters_get_zoom_ratios (GstAHCParameters * self) { JNIEnv *env = gst_dvm_get_env (); jobject list = NULL; - jobject iterator = NULL; GList *ret = NULL; list = AHCP_CALL (return NULL, Object, getZoomRatios); - iterator = java_util_list_iterator (env, list); - if (iterator) { - while (java_util_iterator_has_next (env, iterator)) { - jobject integer = java_util_iterator_next (env, iterator); + if (list) { + jobject iterator = NULL; - if (integer) { - jint value = java_lang_integer_int_value (env, integer); + iterator = java_util_list_iterator (env, list); + if (iterator) { + while (java_util_iterator_has_next (env, iterator)) { + jobject integer = java_util_iterator_next (env, iterator); - ret = g_list_append (ret, GINT_TO_POINTER (value)); - (*env)->DeleteLocalRef (env, integer); + if (integer) { + jint value = java_lang_integer_int_value (env, integer); + + ret = g_list_append (ret, GINT_TO_POINTER (value)); + (*env)->DeleteLocalRef (env, integer); + } } + (*env)->DeleteLocalRef (env, iterator); } - (*env)->DeleteLocalRef (env, iterator); + (*env)->DeleteLocalRef (env, list); } - (*env)->DeleteLocalRef (env, list); return ret; } From 01d6df438da20538ac9afb8e2219ea45e8a78bd6 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 7 Nov 2012 15:38:19 -0500 Subject: [PATCH 48/82] androidcamera: Do not advertise zoom capabilities if camera doesn't support zoom --- sys/androidcamera/gstahcsrc.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 912008b58d..80a670508f 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -1326,10 +1326,24 @@ gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) static GstPhotoCaps gst_ahc_src_get_capabilities (GstPhotography * photo) { - return GST_PHOTOGRAPHY_CAPS_EV_COMP | GST_PHOTOGRAPHY_CAPS_WB_MODE | - GST_PHOTOGRAPHY_CAPS_TONE | GST_PHOTOGRAPHY_CAPS_SCENE | - GST_PHOTOGRAPHY_CAPS_FLASH | GST_PHOTOGRAPHY_CAPS_ZOOM | - GST_PHOTOGRAPHY_CAPS_FOCUS; + GstAHCSrc *self = GST_AHC_SRC (photo); + + GstPhotoCaps caps = GST_PHOTOGRAPHY_CAPS_EV_COMP | + GST_PHOTOGRAPHY_CAPS_WB_MODE | GST_PHOTOGRAPHY_CAPS_TONE | + GST_PHOTOGRAPHY_CAPS_SCENE | GST_PHOTOGRAPHY_CAPS_FLASH | + GST_PHOTOGRAPHY_CAPS_FOCUS | GST_PHOTOGRAPHY_CAPS_ZOOM; + + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (!gst_ahc_parameters_is_zoom_supported (params)) + caps &= ~GST_PHOTOGRAPHY_CAPS_ZOOM; + + gst_ahc_parameters_free (params); + } + + return caps; } static void From 08298ef7f55cdd711420ba0b2bade14017a5dfd1 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 7 Nov 2012 19:16:05 -0500 Subject: [PATCH 49/82] androidcamera: Implement new GstPhotography enums --- sys/androidcamera/gstahcsrc.c | 113 +++++++++++++++++++++++++++------- 1 file changed, 92 insertions(+), 21 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 80a670508f..7f906f50f6 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -704,14 +704,16 @@ gst_ahc_src_get_white_balance_mode (GstPhotography * photo, mode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN; else if (wb == Parameters_WHITE_BALANCE_FLUORESCENT) mode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT; - //else if (wb == Parameters_WHITE_BALANCE_WARM_FLUORESCENT) + else if (wb == Parameters_WHITE_BALANCE_WARM_FLUORESCENT) + mode = GST_PHOTOGRAPHY_WB_MODE_WARM_FLUORESCENT; else if (wb == Parameters_WHITE_BALANCE_DAYLIGHT) mode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT; else if (wb == Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT) mode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY; else if (wb == Parameters_WHITE_BALANCE_TWILIGHT) mode = GST_PHOTOGRAPHY_WB_MODE_SUNSET; - //else if (wb == Parameters_WHITE_BALANCE_SHADE) + else if (wb == Parameters_WHITE_BALANCE_SHADE) + mode = GST_PHOTOGRAPHY_WB_MODE_SHADE; else ret = FALSE; @@ -751,10 +753,14 @@ gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE; else if (effect == Parameters_EFFECT_SEPIA) mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA; - //else if (effect == Parameters_EFFECT_POSTERIZE) - //else if (effect == Parameters_EFFECT_WHITEBOARD) - //else if (effect == Parameters_EFFECT_BLACKBOARD) - //else if (effect == Parameters_EFFECT_AQUA) + else if (effect == Parameters_EFFECT_POSTERIZE) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE; + else if (effect == Parameters_EFFECT_WHITEBOARD) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD; + else if (effect == Parameters_EFFECT_BLACKBOARD) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD; + else if (effect == Parameters_EFFECT_AQUA) + mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA; else ret = FALSE; @@ -785,25 +791,36 @@ gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) ret = TRUE; if (scene == Parameters_SCENE_MODE_AUTO) mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; - //else if (scene == Parameters_SCENE_MODE_ACTION) + else if (scene == Parameters_SCENE_MODE_ACTION) + mode = GST_PHOTOGRAPHY_SCENE_MODE_ACTION; else if (scene == Parameters_SCENE_MODE_PORTRAIT) mode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; else if (scene == Parameters_SCENE_MODE_LANDSCAPE) mode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; else if (scene == Parameters_SCENE_MODE_NIGHT) mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; - //else if (scene == Parameters_SCENE_MODE_NIGHT_PORTRAIT) - //else if (scene == Parameters_SCENE_MODE_THEATRE) - //else if (scene == Parameters_SCENE_MODE_BEACH) - //else if (scene == Parameters_SCENE_MODE_SNOW) - //else if (scene == Parameters_SCENE_MODE_SUNSET) - //else if (scene == Parameters_SCENE_MODE_STEADYPHOTO) - //else if (scene == Parameters_SCENE_MODE_FIREWORKS) + else if (scene == Parameters_SCENE_MODE_NIGHT_PORTRAIT) + mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT; + else if (scene == Parameters_SCENE_MODE_THEATRE) + mode = GST_PHOTOGRAPHY_SCENE_MODE_THEATRE; + else if (scene == Parameters_SCENE_MODE_BEACH) + mode = GST_PHOTOGRAPHY_SCENE_MODE_BEACH; + else if (scene == Parameters_SCENE_MODE_SNOW) + mode = GST_PHOTOGRAPHY_SCENE_MODE_SNOW; + else if (scene == Parameters_SCENE_MODE_SUNSET) + mode = GST_PHOTOGRAPHY_SCENE_MODE_SUNSET; + else if (scene == Parameters_SCENE_MODE_STEADYPHOTO) + mode = GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO; + else if (scene == Parameters_SCENE_MODE_FIREWORKS) + mode = GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS; else if (scene == Parameters_SCENE_MODE_SPORTS) mode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; - //else if (scene == Parameters_SCENE_MODE_PARTY) - //else if (scene == Parameters_SCENE_MODE_CANDLELIGHT) - //else if (scene == Parameters_SCENE_MODE_BARCODE) + else if (scene == Parameters_SCENE_MODE_PARTY) + mode = GST_PHOTOGRAPHY_SCENE_MODE_PARTY; + else if (scene == Parameters_SCENE_MODE_CANDLELIGHT) + mode = GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT; + else if (scene == Parameters_SCENE_MODE_BARCODE) + mode = GST_PHOTOGRAPHY_SCENE_MODE_BARCODE; else ret = FALSE; @@ -946,9 +963,10 @@ gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode) mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY; else if (focus == Parameters_FOCUS_MODE_MACRO) mode = GST_PHOTOGRAPHY_FOCUS_MODE_MACRO; - //else if (focus == Parameters_FOCUS_MODE_FIXED) - else if (focus == Parameters_FOCUS_MODE_EDOF) + else if (focus == Parameters_FOCUS_MODE_FIXED) mode = GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL; + else if (focus == Parameters_FOCUS_MODE_EDOF) + mode = GST_PHOTOGRAPHY_FOCUS_MODE_EXTENDED; else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_VIDEO) mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED; else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_PICTURE) @@ -1032,6 +1050,12 @@ gst_ahc_src_set_white_balance_mode (GstPhotography * photo, case GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT: white_balance = Parameters_WHITE_BALANCE_FLUORESCENT; break; + case GST_PHOTOGRAPHY_WB_MODE_WARM_FLUORESCENT: + white_balance = Parameters_WHITE_BALANCE_WARM_FLUORESCENT; + break; + case GST_PHOTOGRAPHY_WB_MODE_SHADE: + white_balance = Parameters_WHITE_BALANCE_SHADE; + break; default: white_balance = NULL; break; @@ -1078,6 +1102,18 @@ gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE: color_effect = Parameters_EFFECT_SOLARIZE; break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE: + color_effect = Parameters_EFFECT_POSTERIZE; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD: + color_effect = Parameters_EFFECT_WHITEBOARD; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD: + color_effect = Parameters_EFFECT_BLACKBOARD; + break; + case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA: + color_effect = Parameters_EFFECT_AQUA; + break; case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NATURAL: case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_VIVID: case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_COLORSWAP: @@ -1130,6 +1166,39 @@ gst_ahc_src_set_scene_mode (GstPhotography * photo, GstSceneMode scene_mode) case GST_PHOTOGRAPHY_SCENE_MODE_AUTO: scene = Parameters_SCENE_MODE_AUTO; break; + case GST_PHOTOGRAPHY_SCENE_MODE_ACTION: + scene = Parameters_SCENE_MODE_ACTION; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT: + scene = Parameters_SCENE_MODE_NIGHT_PORTRAIT; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_THEATRE: + scene = Parameters_SCENE_MODE_THEATRE; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_BEACH: + scene = Parameters_SCENE_MODE_BEACH; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_SNOW: + scene = Parameters_SCENE_MODE_SNOW; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_SUNSET: + scene = Parameters_SCENE_MODE_SUNSET; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO: + scene = Parameters_SCENE_MODE_STEADYPHOTO; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS: + scene = Parameters_SCENE_MODE_FIREWORKS; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_PARTY: + scene = Parameters_SCENE_MODE_PARTY; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT: + scene = Parameters_SCENE_MODE_CANDLELIGHT; + break; + case GST_PHOTOGRAPHY_SCENE_MODE_BARCODE: + scene = Parameters_SCENE_MODE_BARCODE; + break; case GST_PHOTOGRAPHY_SCENE_MODE_MANUAL: case GST_PHOTOGRAPHY_SCENE_MODE_CLOSEUP: default: @@ -1297,7 +1366,7 @@ gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) focus = Parameters_FOCUS_MODE_INFINITY; break; case GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL: - focus = Parameters_FOCUS_MODE_EDOF; + focus = Parameters_FOCUS_MODE_FIXED; break; case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL: focus = Parameters_FOCUS_MODE_CONTINUOUS_PICTURE; @@ -1305,8 +1374,10 @@ gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) case GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED: focus = Parameters_FOCUS_MODE_CONTINUOUS_VIDEO; break; - case GST_PHOTOGRAPHY_FOCUS_MODE_PORTRAIT: case GST_PHOTOGRAPHY_FOCUS_MODE_EXTENDED: + focus = Parameters_FOCUS_MODE_EDOF; + break; + case GST_PHOTOGRAPHY_FOCUS_MODE_PORTRAIT: default: focus = NULL; break; From 5975d396e0820efe3282f00e50402e1b5d985e65 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 9 Nov 2012 12:22:12 -0500 Subject: [PATCH 50/82] androidcamera: Fix EV compensation support --- sys/androidcamera/gstahcsrc.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 7f906f50f6..9cf3ad2ce2 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -582,7 +582,7 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, params = gst_ah_camera_get_parameters (self->camera); if (params) { gint min, max; - gfloat step, ev; + gfloat step; min = gst_ahc_parameters_get_min_exposure_compensation (params); max = gst_ahc_parameters_get_max_exposure_compensation (params); @@ -590,14 +590,14 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, if (step != 0.0 && min != max) { GValue value = { 0 }; - gint i, total = 0; + gint i; - total = (max - min) / step; - - array = g_value_array_new (total); + /* Min and Max are inclusive */ + array = g_value_array_new (max - min + 1); g_value_init (&value, G_TYPE_FLOAT); - for (i = 0, ev = min; i < total && ev < max; i++, ev += step) { - g_value_set_float (&value, ev); + for (i = min; i <= max; i++) { + /* floats are bad... :( */ + g_value_set_float (&value, step * i); g_value_array_append (array, &value); } g_value_unset (&value); @@ -670,7 +670,7 @@ gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp) max = gst_ahc_parameters_get_max_exposure_compensation (params); step = gst_ahc_parameters_get_exposure_compensation_step (params); - if (step != 0.0 && min != max && ev >= min && ev <= max) { + if (step != 0.0 && min != max && min <= ev && ev <= max) { if (ev_comp) *ev_comp = ev * step; ret = TRUE; @@ -1001,9 +1001,10 @@ gst_ahc_src_set_ev_compensation (GstPhotography * photo, gfloat ev_comp) ev = gst_ahc_parameters_get_exposure_compensation (params); min = gst_ahc_parameters_get_min_exposure_compensation (params); - max = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_max_exposure_compensation (params); step = gst_ahc_parameters_get_exposure_compensation_step (params); - if (step != 0.0 && min != max && ev_comp >= min && ev_comp <= max) { + if (step != 0.0 && min != max && + (min * step) <= ev_comp && ev_comp <= (max * step)) { ev = ev_comp / step; if ((ev * step) == ev_comp) { gst_ahc_parameters_set_exposure_compensation (params, ev); From dd78e052aebe031549b429931f0fc4f783ab02d4 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 9 Nov 2012 12:23:37 -0500 Subject: [PATCH 51/82] androidcamera: Handle zoom comparison better, and avoid float precision issue --- sys/androidcamera/gstahcsrc.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 9cf3ad2ce2..e39d4d4864 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -1280,12 +1280,12 @@ gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { gint i; + gint value = zoom * 100; for (i = 0; i < max_zoom + 1; i++) { gint zoom_value = GPOINTER_TO_INT (g_list_nth_data (zoom_ratios, i)); - gfloat value = (gfloat) zoom_value / 100.0; - if (value == zoom) + if (value == zoom_value) zoom_idx = i; } } From 0a2530ef7989ba3ca89efc3f1fa97c5bbca63fa5 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 9 Nov 2012 16:55:57 -0500 Subject: [PATCH 52/82] androidcamera: Store GParamSpec for properties and use that for the PropertyProbe comparison --- sys/androidcamera/gstahcsrc.c | 226 ++++++++++++++++++++-------------- 1 file changed, 133 insertions(+), 93 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index e39d4d4864..48f518959f 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -140,8 +140,11 @@ enum PROP_FLICKER_MODE, PROP_FOCUS_MODE, PROP_ZOOM, + PROP_LAST }; +static GParamSpec *properties[PROP_LAST]; + #define DEFAULT_DEVICE "0" GST_BOILERPLATE_FULL (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC, @@ -237,55 +240,105 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstpushsrc_class->create = gst_ahc_src_create; + properties[PROP_DEVICE] = g_param_spec_string ("device", + "device", "Device ID", DEFAULT_DEVICE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE, - g_param_spec_string ("device", "device", - "Device ID", DEFAULT_DEVICE, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); + properties[PROP_DEVICE]); + properties[PROP_DEVICE_ORIENTATION] = g_param_spec_int ("device-orientation", + "Device orientation", "The orientation of the camera image", + 0, 360, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE_ORIENTATION, - g_param_spec_int ("device-orientation", "Device orientation", - "The orientation of the camera image", - 0, 360, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + properties[PROP_DEVICE_ORIENTATION]); + properties[PROP_DEVICE_FACING] = g_param_spec_enum ("device-facing", + "Device facing", "The direction that the camera faces", + GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE_FACING, - g_param_spec_enum ("device-facing", "Device facing", - "The direction that the camera faces", - GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, - G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + properties[PROP_DEVICE_FACING]); /* Override GstPhotography properties */ g_object_class_override_property (gobject_class, PROP_WB_MODE, GST_PHOTOGRAPHY_PROP_WB_MODE); + properties[PROP_WB_MODE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_WB_MODE); + g_object_class_override_property (gobject_class, PROP_COLOUR_TONE, GST_PHOTOGRAPHY_PROP_COLOUR_TONE); + properties[PROP_COLOUR_TONE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_COLOUR_TONE); + g_object_class_override_property (gobject_class, PROP_SCENE_MODE, GST_PHOTOGRAPHY_PROP_SCENE_MODE); + properties[PROP_SCENE_MODE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_SCENE_MODE); + g_object_class_override_property (gobject_class, PROP_FLASH_MODE, GST_PHOTOGRAPHY_PROP_FLASH_MODE); + properties[PROP_FLASH_MODE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_FLASH_MODE); + g_object_class_override_property (gobject_class, PROP_NOISE_REDUCTION, GST_PHOTOGRAPHY_PROP_NOISE_REDUCTION); + properties[PROP_NOISE_REDUCTION] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_NOISE_REDUCTION); + g_object_class_override_property (gobject_class, PROP_CAPABILITIES, GST_PHOTOGRAPHY_PROP_CAPABILITIES); + properties[PROP_CAPABILITIES] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_CAPABILITIES); + g_object_class_override_property (gobject_class, PROP_EV_COMP, GST_PHOTOGRAPHY_PROP_EV_COMP); + properties[PROP_EV_COMP] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_EV_COMP); + g_object_class_override_property (gobject_class, PROP_ISO_SPEED, GST_PHOTOGRAPHY_PROP_ISO_SPEED); + properties[PROP_ISO_SPEED] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_ISO_SPEED); + g_object_class_override_property (gobject_class, PROP_APERTURE, GST_PHOTOGRAPHY_PROP_APERTURE); + properties[PROP_APERTURE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_APERTURE); + g_object_class_override_property (gobject_class, PROP_EXPOSURE, GST_PHOTOGRAPHY_PROP_EXPOSURE); + properties[PROP_EXPOSURE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_EXPOSURE); + g_object_class_override_property (gobject_class, PROP_IMAGE_CAPTURE_SUPPORTED_CAPS, GST_PHOTOGRAPHY_PROP_IMAGE_CAPTURE_SUPPORTED_CAPS); + properties[PROP_IMAGE_CAPTURE_SUPPORTED_CAPS] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_IMAGE_CAPTURE_SUPPORTED_CAPS); + g_object_class_override_property (gobject_class, PROP_IMAGE_PREVIEW_SUPPORTED_CAPS, GST_PHOTOGRAPHY_PROP_IMAGE_PREVIEW_SUPPORTED_CAPS); + properties[PROP_IMAGE_PREVIEW_SUPPORTED_CAPS] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_IMAGE_PREVIEW_SUPPORTED_CAPS); + g_object_class_override_property (gobject_class, PROP_FLICKER_MODE, GST_PHOTOGRAPHY_PROP_FLICKER_MODE); + properties[PROP_FLICKER_MODE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_FLICKER_MODE); + g_object_class_override_property (gobject_class, PROP_FOCUS_MODE, GST_PHOTOGRAPHY_PROP_FOCUS_MODE); + properties[PROP_FOCUS_MODE] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_FOCUS_MODE); + g_object_class_override_property (gobject_class, PROP_ZOOM, GST_PHOTOGRAPHY_PROP_ZOOM); + properties[PROP_ZOOM] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_ZOOM); klass->probe_properties = NULL; } @@ -532,19 +585,16 @@ gst_ahc_src_implements_interface_init (GstImplementsInterfaceClass * klass) static const GList * gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) { - GObjectClass *klass = G_OBJECT_GET_CLASS (probe); GstAHCSrcClass *ahc_class = GST_AHC_SRC_CLASS (probe); + GList **list = &ahc_class->probe_properties; - if (!ahc_class->probe_properties) { - ahc_class->probe_properties = g_list_append (NULL, - g_object_class_find_property (klass, "device")); - ahc_class->probe_properties = g_list_append (ahc_class->probe_properties, - g_object_class_find_property (klass, GST_PHOTOGRAPHY_PROP_EV_COMP)); - ahc_class->probe_properties = g_list_append (ahc_class->probe_properties, - g_object_class_find_property (klass, GST_PHOTOGRAPHY_PROP_ZOOM)); + if (!*list) { + *list = g_list_append (*list, properties[PROP_DEVICE]); + *list = g_list_append (*list, properties[PROP_EV_COMP]); + *list = g_list_append (*list, properties[PROP_ZOOM]); } - return ahc_class->probe_properties; + return *list; } static GValueArray * @@ -554,90 +604,80 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, GstAHCSrc *self = GST_AHC_SRC (probe); GValueArray *array = NULL; - switch (prop_id) { - case PROP_DEVICE:{ - GValue value = { 0 }; - gint num_cams = gst_ah_camera_get_number_of_cameras (); - gint i; + /* g_object_class_find_property returns overriden property with + * param_id == 0, so we can't switch/case the prop_id and + * we need to check the pspec instead */ + if (pspec == properties[PROP_DEVICE]) { + GValue value = { 0 }; + gint num_cams = gst_ah_camera_get_number_of_cameras (); + gint i; - array = g_value_array_new (num_cams); - g_value_init (&value, G_TYPE_STRING); - for (i = 0; i < num_cams; i++) { - g_value_take_string (&value, g_strdup_printf ("%d", i)); - g_value_array_append (array, &value); - } - g_value_unset (&value); + array = g_value_array_new (num_cams); + g_value_init (&value, G_TYPE_STRING); + for (i = 0; i < num_cams; i++) { + g_value_take_string (&value, g_strdup_printf ("%d", i)); + g_value_array_append (array, &value); } - break; - default: - /* g_object_class_find_property returns overriden property with - * param_id == 0, so we can't switch/case the prop_id and - * g_param_spec_get_redirect_target() returns NULL, so we need to - * do a strcmp on the property's name instead */ - if (!g_strcmp0 (pspec->name, GST_PHOTOGRAPHY_PROP_EV_COMP)) { - //case PROP_EV_COMP: - if (self->camera) { - GstAHCParameters *params; + g_value_unset (&value); + } else if (pspec == properties[PROP_EV_COMP]) { + if (self->camera) { + GstAHCParameters *params; - params = gst_ah_camera_get_parameters (self->camera); - if (params) { - gint min, max; - gfloat step; + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gint min, max; + gfloat step; - min = gst_ahc_parameters_get_min_exposure_compensation (params); - max = gst_ahc_parameters_get_max_exposure_compensation (params); - step = gst_ahc_parameters_get_exposure_compensation_step (params); + min = gst_ahc_parameters_get_min_exposure_compensation (params); + max = gst_ahc_parameters_get_max_exposure_compensation (params); + step = gst_ahc_parameters_get_exposure_compensation_step (params); - if (step != 0.0 && min != max) { - GValue value = { 0 }; - gint i; + if (step != 0.0 && min != max) { + GValue value = { 0 }; + gint i; - /* Min and Max are inclusive */ - array = g_value_array_new (max - min + 1); - g_value_init (&value, G_TYPE_FLOAT); - for (i = min; i <= max; i++) { - /* floats are bad... :( */ - g_value_set_float (&value, step * i); - g_value_array_append (array, &value); - } - g_value_unset (&value); - } - - gst_ahc_parameters_free (params); + /* Min and Max are inclusive */ + array = g_value_array_new (max - min + 1); + g_value_init (&value, G_TYPE_FLOAT); + for (i = min; i <= max; i++) { + g_value_set_float (&value, step * i); + g_value_array_append (array, &value); } + g_value_unset (&value); } - } else if (!g_strcmp0 (pspec->name, GST_PHOTOGRAPHY_PROP_ZOOM)) { - //case PROP_ZOOM: - if (self->camera) { - GstAHCParameters *params; - params = gst_ah_camera_get_parameters (self->camera); - if (params) { - GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); - gint max_zoom = gst_ahc_parameters_get_max_zoom (params); - - if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { - GValue value = { 0 }; - GList *i; - - array = g_value_array_new (max_zoom + 1); - g_value_init (&value, G_TYPE_FLOAT); - for (i = zoom_ratios; i; i = i->next) { - gint zoom_value = GPOINTER_TO_INT (i->data); - gfloat zoom = (gfloat) zoom_value / 100.0; - - g_value_set_float (&value, zoom); - g_value_array_append (array, &value); - } - g_value_unset (&value); - } - gst_ahc_parameters_free (params); - } - } - } else { - G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + gst_ahc_parameters_free (params); } - break; + } + } else if (pspec == properties[PROP_ZOOM]) { + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + GList *zoom_ratios = gst_ahc_parameters_get_zoom_ratios (params); + gint max_zoom = gst_ahc_parameters_get_max_zoom (params); + + if (zoom_ratios && g_list_length (zoom_ratios) == (max_zoom + 1)) { + GValue value = { 0 }; + GList *i; + + array = g_value_array_new (max_zoom + 1); + g_value_init (&value, G_TYPE_FLOAT); + for (i = zoom_ratios; i; i = i->next) { + gint zoom_value = GPOINTER_TO_INT (i->data); + gfloat zoom = (gfloat) zoom_value / 100.0; + + g_value_set_float (&value, zoom); + g_value_array_append (array, &value); + } + g_value_unset (&value); + } + gst_ahc_parameters_free (params); + } + } + } else { + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); } return array; From 0a8804110fe64b104ac2cecbba25a5934915f548 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 9 Nov 2012 16:57:30 -0500 Subject: [PATCH 53/82] androidcamera: Fix small memleak --- sys/androidcamera/gstahcsrc.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 48f518959f..efb4c83aa7 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -673,6 +673,8 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, } g_value_unset (&value); } + + gst_ahc_parameters_zoom_ratios_free (zoom_ratios); gst_ahc_parameters_free (params); } } @@ -937,6 +939,7 @@ gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom) ret = TRUE; } + gst_ahc_parameters_zoom_ratios_free (zoom_ratios); gst_ahc_parameters_free (params); } @@ -1329,10 +1332,13 @@ gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) zoom_idx = i; } } + if (zoom_idx != -1) { gst_ahc_parameters_set_zoom (params, zoom_idx); ret = gst_ah_camera_set_parameters (self->camera, params); } + + gst_ahc_parameters_zoom_ratios_free (zoom_ratios); gst_ahc_parameters_free (params); } } @@ -1655,8 +1661,8 @@ gst_ahc_src_getcaps (GstBaseSrc * src) gst_ahc_parameters_supported_preview_formats_free (formats); gst_ahc_parameters_supported_preview_sizes_free (sizes); gst_ahc_parameters_supported_preview_fps_range_free (ranges); + gst_ahc_parameters_free (params); } - gst_ahc_parameters_free (params); return ret; } else { From f69448ef13b9bb7218d76394788217a1f988dd5e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Fri, 9 Nov 2012 18:21:21 -0500 Subject: [PATCH 54/82] androidcamera: Small refactor --- sys/androidcamera/gstahcsrc.c | 319 ++++++++++++++++++++-------------- 1 file changed, 191 insertions(+), 128 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index efb4c83aa7..4fb8027009 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -65,17 +65,26 @@ static void gst_ahc_src_init_interfaces (GType type); /* GstPhotography */ static gboolean gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp); +static gboolean _white_balance_to_enum (const gchar * white_balance, + GstWhiteBalanceMode * mode); static gboolean gst_ahc_src_get_white_balance_mode (GstPhotography * photo, GstWhiteBalanceMode * wb_mode); +static gboolean _color_effects_to_enum (const gchar * color_effect, + GstColourToneMode * mode); static gboolean gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, GstColourToneMode * tone_mode); +static gboolean _scene_modes_to_enum (const gchar * scene, GstSceneMode * mode); static gboolean gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode); +static gboolean _flash_modes_to_enum (const gchar * flash, GstFlashMode * mode); static gboolean gst_ahc_src_get_flash_mode (GstPhotography * photo, GstFlashMode * flash_mode); static gboolean gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom); +static gboolean _antibanding_to_enum (const gchar * antibanding, + GstFlickerReductionMode * mode); static gboolean gst_ahc_src_get_flicker_mode (GstPhotography * photo, GstFlickerReductionMode * flicker_mode); +static gboolean _focus_modes_to_enum (const gchar * focus, GstFocusMode * mode); static gboolean gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode); @@ -693,6 +702,158 @@ gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface * iface) } +static gboolean +_antibanding_to_enum (const gchar * antibanding, GstFlickerReductionMode * mode) +{ + if (antibanding == Parameters_ANTIBANDING_AUTO) + *mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; + else if (antibanding == Parameters_ANTIBANDING_50HZ) + *mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_50HZ; + else if (antibanding == Parameters_ANTIBANDING_60HZ) + *mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_60HZ; + else if (antibanding == Parameters_ANTIBANDING_OFF) + *mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF; + else + return FALSE; + + return TRUE; +} + +static gboolean +_white_balance_to_enum (const gchar * white_balance, GstWhiteBalanceMode * mode) +{ + if (white_balance == Parameters_WHITE_BALANCE_AUTO) + *mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; + else if (white_balance == Parameters_WHITE_BALANCE_INCANDESCENT) + *mode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN; + else if (white_balance == Parameters_WHITE_BALANCE_FLUORESCENT) + *mode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT; + else if (white_balance == Parameters_WHITE_BALANCE_WARM_FLUORESCENT) + *mode = GST_PHOTOGRAPHY_WB_MODE_WARM_FLUORESCENT; + else if (white_balance == Parameters_WHITE_BALANCE_DAYLIGHT) + *mode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT; + else if (white_balance == Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT) + *mode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY; + else if (white_balance == Parameters_WHITE_BALANCE_TWILIGHT) + *mode = GST_PHOTOGRAPHY_WB_MODE_SUNSET; + else if (white_balance == Parameters_WHITE_BALANCE_SHADE) + *mode = GST_PHOTOGRAPHY_WB_MODE_SHADE; + else + return FALSE; + + return TRUE; +} + +static gboolean +_color_effects_to_enum (const gchar * color_effect, GstColourToneMode * mode) +{ + if (color_effect == Parameters_EFFECT_NONE) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; + else if (color_effect == Parameters_EFFECT_MONO) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE; + else if (color_effect == Parameters_EFFECT_NEGATIVE) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE; + else if (color_effect == Parameters_EFFECT_SOLARIZE) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE; + else if (color_effect == Parameters_EFFECT_SEPIA) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA; + else if (color_effect == Parameters_EFFECT_POSTERIZE) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE; + else if (color_effect == Parameters_EFFECT_WHITEBOARD) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD; + else if (color_effect == Parameters_EFFECT_BLACKBOARD) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD; + else if (color_effect == Parameters_EFFECT_AQUA) + *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA; + else + return FALSE; + + return TRUE; +} + +static gboolean +_scene_modes_to_enum (const gchar * scene, GstSceneMode * mode) +{ + if (scene == Parameters_SCENE_MODE_AUTO) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + else if (scene == Parameters_SCENE_MODE_ACTION) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_ACTION; + else if (scene == Parameters_SCENE_MODE_PORTRAIT) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; + else if (scene == Parameters_SCENE_MODE_LANDSCAPE) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; + else if (scene == Parameters_SCENE_MODE_NIGHT) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; + else if (scene == Parameters_SCENE_MODE_NIGHT_PORTRAIT) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT; + else if (scene == Parameters_SCENE_MODE_THEATRE) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_THEATRE; + else if (scene == Parameters_SCENE_MODE_BEACH) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_BEACH; + else if (scene == Parameters_SCENE_MODE_SNOW) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_SNOW; + else if (scene == Parameters_SCENE_MODE_SUNSET) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_SUNSET; + else if (scene == Parameters_SCENE_MODE_STEADYPHOTO) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO; + else if (scene == Parameters_SCENE_MODE_FIREWORKS) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS; + else if (scene == Parameters_SCENE_MODE_SPORTS) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; + else if (scene == Parameters_SCENE_MODE_PARTY) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_PARTY; + else if (scene == Parameters_SCENE_MODE_CANDLELIGHT) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT; + else if (scene == Parameters_SCENE_MODE_BARCODE) + *mode = GST_PHOTOGRAPHY_SCENE_MODE_BARCODE; + else + return FALSE; + + return TRUE; +} + +static gboolean +_flash_modes_to_enum (const gchar * flash, GstFlashMode * mode) +{ + if (flash == Parameters_FLASH_MODE_OFF) + *mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; + else if (flash == Parameters_FLASH_MODE_AUTO) + *mode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO; + else if (flash == Parameters_FLASH_MODE_ON) + *mode = GST_PHOTOGRAPHY_FLASH_MODE_ON; + else if (flash == Parameters_FLASH_MODE_RED_EYE) + *mode = GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE; + else if (flash == Parameters_FLASH_MODE_TORCH) + *mode = GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN; + else + return FALSE; + + return TRUE; +} + +static gboolean +_focus_modes_to_enum (const gchar * focus, GstFocusMode * mode) +{ + if (focus == Parameters_FOCUS_MODE_AUTO) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; + else if (focus == Parameters_FOCUS_MODE_INFINITY) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY; + else if (focus == Parameters_FOCUS_MODE_MACRO) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_MACRO; + else if (focus == Parameters_FOCUS_MODE_FIXED) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL; + else if (focus == Parameters_FOCUS_MODE_EDOF) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_EXTENDED; + else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_VIDEO) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED; + else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_PICTURE) + *mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL; + else + return FALSE; + + return TRUE; +} + static gboolean gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp) { @@ -739,28 +900,12 @@ gst_ahc_src_get_white_balance_mode (GstPhotography * photo, const gchar *wb = gst_ahc_parameters_get_white_balance (params); GstWhiteBalanceMode mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; - ret = TRUE; - if (wb == Parameters_WHITE_BALANCE_AUTO) - mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; - else if (wb == Parameters_WHITE_BALANCE_INCANDESCENT) - mode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN; - else if (wb == Parameters_WHITE_BALANCE_FLUORESCENT) - mode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT; - else if (wb == Parameters_WHITE_BALANCE_WARM_FLUORESCENT) - mode = GST_PHOTOGRAPHY_WB_MODE_WARM_FLUORESCENT; - else if (wb == Parameters_WHITE_BALANCE_DAYLIGHT) - mode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT; - else if (wb == Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT) - mode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY; - else if (wb == Parameters_WHITE_BALANCE_TWILIGHT) - mode = GST_PHOTOGRAPHY_WB_MODE_SUNSET; - else if (wb == Parameters_WHITE_BALANCE_SHADE) - mode = GST_PHOTOGRAPHY_WB_MODE_SHADE; - else - ret = FALSE; + if (_white_balance_to_enum (wb, &mode)) { + ret = TRUE; - if (ret && wb_mode) - *wb_mode = mode; + if (wb_mode) + *wb_mode = mode; + } gst_ahc_parameters_free (params); } @@ -784,30 +929,12 @@ gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, const gchar *effect = gst_ahc_parameters_get_color_effect (params); GstColourToneMode mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; - ret = TRUE; - if (effect == Parameters_EFFECT_NONE) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; - else if (effect == Parameters_EFFECT_MONO) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE; - else if (effect == Parameters_EFFECT_NEGATIVE) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE; - else if (effect == Parameters_EFFECT_SOLARIZE) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE; - else if (effect == Parameters_EFFECT_SEPIA) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA; - else if (effect == Parameters_EFFECT_POSTERIZE) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE; - else if (effect == Parameters_EFFECT_WHITEBOARD) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD; - else if (effect == Parameters_EFFECT_BLACKBOARD) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD; - else if (effect == Parameters_EFFECT_AQUA) - mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA; - else - ret = FALSE; + if (_color_effects_to_enum (effect, &mode)) { + ret = TRUE; - if (ret && tone_mode) - *tone_mode = mode; + if (tone_mode) + *tone_mode = mode; + } gst_ahc_parameters_free (params); } @@ -830,44 +957,12 @@ gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) const gchar *scene = gst_ahc_parameters_get_scene_mode (params); GstSceneMode mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; - ret = TRUE; - if (scene == Parameters_SCENE_MODE_AUTO) - mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; - else if (scene == Parameters_SCENE_MODE_ACTION) - mode = GST_PHOTOGRAPHY_SCENE_MODE_ACTION; - else if (scene == Parameters_SCENE_MODE_PORTRAIT) - mode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT; - else if (scene == Parameters_SCENE_MODE_LANDSCAPE) - mode = GST_PHOTOGRAPHY_SCENE_MODE_LANDSCAPE; - else if (scene == Parameters_SCENE_MODE_NIGHT) - mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT; - else if (scene == Parameters_SCENE_MODE_NIGHT_PORTRAIT) - mode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT_PORTRAIT; - else if (scene == Parameters_SCENE_MODE_THEATRE) - mode = GST_PHOTOGRAPHY_SCENE_MODE_THEATRE; - else if (scene == Parameters_SCENE_MODE_BEACH) - mode = GST_PHOTOGRAPHY_SCENE_MODE_BEACH; - else if (scene == Parameters_SCENE_MODE_SNOW) - mode = GST_PHOTOGRAPHY_SCENE_MODE_SNOW; - else if (scene == Parameters_SCENE_MODE_SUNSET) - mode = GST_PHOTOGRAPHY_SCENE_MODE_SUNSET; - else if (scene == Parameters_SCENE_MODE_STEADYPHOTO) - mode = GST_PHOTOGRAPHY_SCENE_MODE_STEADY_PHOTO; - else if (scene == Parameters_SCENE_MODE_FIREWORKS) - mode = GST_PHOTOGRAPHY_SCENE_MODE_FIREWORKS; - else if (scene == Parameters_SCENE_MODE_SPORTS) - mode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT; - else if (scene == Parameters_SCENE_MODE_PARTY) - mode = GST_PHOTOGRAPHY_SCENE_MODE_PARTY; - else if (scene == Parameters_SCENE_MODE_CANDLELIGHT) - mode = GST_PHOTOGRAPHY_SCENE_MODE_CANDLELIGHT; - else if (scene == Parameters_SCENE_MODE_BARCODE) - mode = GST_PHOTOGRAPHY_SCENE_MODE_BARCODE; - else - ret = FALSE; + if (_scene_modes_to_enum (scene, &mode)) { + ret = TRUE; - if (ret && scene_mode) - *scene_mode = mode; + if (scene_mode) + *scene_mode = mode; + } gst_ahc_parameters_free (params); } @@ -890,22 +985,12 @@ gst_ahc_src_get_flash_mode (GstPhotography * photo, GstFlashMode * flash_mode) const gchar *flash = gst_ahc_parameters_get_flash_mode (params); GstFlashMode mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; - ret = TRUE; - if (flash == Parameters_FLASH_MODE_OFF) - mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; - else if (flash == Parameters_FLASH_MODE_AUTO) - mode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO; - else if (flash == Parameters_FLASH_MODE_ON) - mode = GST_PHOTOGRAPHY_FLASH_MODE_ON; - else if (flash == Parameters_FLASH_MODE_RED_EYE) - mode = GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE; - else if (flash == Parameters_FLASH_MODE_TORCH) - mode = GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN; - else - ret = FALSE; + if (_flash_modes_to_enum (flash, &mode)) { + ret = TRUE; - if (ret && flash_mode) - *flash_mode = mode; + if (flash_mode) + *flash_mode = mode; + } gst_ahc_parameters_free (params); } @@ -963,20 +1048,12 @@ gst_ahc_src_get_flicker_mode (GstPhotography * photo, const gchar *antibanding = gst_ahc_parameters_get_antibanding (params); GstFlickerReductionMode mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; - ret = TRUE; - if (antibanding == Parameters_ANTIBANDING_AUTO) - mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; - else if (antibanding == Parameters_ANTIBANDING_50HZ) - mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_50HZ; - else if (antibanding == Parameters_ANTIBANDING_60HZ) - mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_60HZ; - else if (antibanding == Parameters_ANTIBANDING_OFF) - mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF; - else - ret = FALSE; + if (_antibanding_to_enum (antibanding, &mode)) { + ret = TRUE; - if (ret && flicker_mode) - *flicker_mode = mode; + if (flicker_mode) + *flicker_mode = mode; + } gst_ahc_parameters_free (params); } @@ -999,26 +1076,12 @@ gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode) const gchar *focus = gst_ahc_parameters_get_focus_mode (params); GstFocusMode mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; - ret = TRUE; - if (focus == Parameters_FOCUS_MODE_AUTO) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; - else if (focus == Parameters_FOCUS_MODE_INFINITY) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_INFINITY; - else if (focus == Parameters_FOCUS_MODE_MACRO) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_MACRO; - else if (focus == Parameters_FOCUS_MODE_FIXED) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_HYPERFOCAL; - else if (focus == Parameters_FOCUS_MODE_EDOF) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_EXTENDED; - else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_VIDEO) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_EXTENDED; - else if (focus == Parameters_FOCUS_MODE_CONTINUOUS_PICTURE) - mode = GST_PHOTOGRAPHY_FOCUS_MODE_CONTINUOUS_NORMAL; - else - ret = FALSE; + if (_focus_modes_to_enum (focus, &mode)) { + ret = TRUE; - if (ret && focus_mode) - *focus_mode = mode; + if (focus_mode) + *focus_mode = mode; + } gst_ahc_parameters_free (params); } From a79beef1c3971f45667f3d41eab1e757711ee3f9 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 12 Nov 2012 16:38:40 -0500 Subject: [PATCH 55/82] androidcamera: Add property probe for the photography properties --- sys/androidcamera/gstahcsrc.c | 53 +++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 4fb8027009..2f7b2e13fb 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -601,11 +601,49 @@ gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) *list = g_list_append (*list, properties[PROP_DEVICE]); *list = g_list_append (*list, properties[PROP_EV_COMP]); *list = g_list_append (*list, properties[PROP_ZOOM]); + *list = g_list_append (*list, properties[PROP_WB_MODE]); + *list = g_list_append (*list, properties[PROP_COLOUR_TONE]); + *list = g_list_append (*list, properties[PROP_FLASH_MODE]); + *list = g_list_append (*list, properties[PROP_FOCUS_MODE]); + *list = g_list_append (*list, properties[PROP_SCENE_MODE]); + *list = g_list_append (*list, properties[PROP_FLICKER_MODE]); } return *list; } +#define PROBE_GET_ENUM_VALUES(name, type, struct_name) \ + if (self->camera) { \ + GstAHCParameters *params; \ + \ + params = gst_ah_camera_get_parameters (self->camera); \ + if (params) { \ + GList *list = gst_ahc_parameters_get_supported_##name (params); \ + \ + if (list) { \ + GValue value = { 0 }; \ + GList *i; \ + \ + array = g_value_array_new (g_list_length (list)); \ + g_value_init (&value, type); \ + for (i = list; i; i = i->next) { \ + struct_name mode; \ + const gchar *name = i->data; \ + \ + if (_##name##_to_enum (name, &mode)) { \ + g_value_set_enum (&value, mode); \ + g_value_array_append (array, &value); \ + } \ + } \ + g_value_unset (&value); \ + } \ + \ + gst_ahc_parameters_supported_##name##_free (list); \ + gst_ahc_parameters_free (params); \ + } \ + } + + static GValueArray * gst_ahc_src_probe_get_values (GstPropertyProbe * probe, guint prop_id, const GParamSpec * pspec) @@ -687,6 +725,21 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, gst_ahc_parameters_free (params); } } + } else if (pspec == properties[PROP_WB_MODE]) { + PROBE_GET_ENUM_VALUES (white_balance, GST_TYPE_WHITE_BALANCE_MODE, + GstWhiteBalanceMode); + } else if (pspec == properties[PROP_COLOUR_TONE]) { + PROBE_GET_ENUM_VALUES (color_effects, GST_TYPE_COLOUR_TONE_MODE, + GstColourToneMode); + } else if (pspec == properties[PROP_FLASH_MODE]) { + PROBE_GET_ENUM_VALUES (flash_modes, GST_TYPE_FLASH_MODE, GstFlashMode); + } else if (pspec == properties[PROP_FOCUS_MODE]) { + PROBE_GET_ENUM_VALUES (focus_modes, GST_TYPE_FOCUS_MODE, GstFocusMode); + } else if (pspec == properties[PROP_SCENE_MODE]) { + PROBE_GET_ENUM_VALUES (scene_modes, GST_TYPE_SCENE_MODE, GstSceneMode); + } else if (pspec == properties[PROP_FLICKER_MODE]) { + PROBE_GET_ENUM_VALUES (antibanding, GST_TYPE_FLICKER_REDUCTION_MODE, + GstFlickerReductionMode); } else { G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); } From eea2904e9d8a5e1cc1e4b58745b661021a7eb25f Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 12 Nov 2012 18:18:11 -0500 Subject: [PATCH 56/82] androidcamera: Add video stabilization API --- .../gst-android-hardware-camera.c | 45 +++++++++++++++++++ .../gst-android-hardware-camera.h | 5 +++ 2 files changed, 50 insertions(+) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 2352e93c86..92dc95d4d6 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -104,10 +104,12 @@ static struct jmethodID getSupportedSceneModes; jmethodID getSupportedWhiteBalance; jmethodID getVerticalViewAngle; + jmethodID getVideoStabilization; jmethodID getWhiteBalance; jmethodID getZoom; jmethodID getZoomRatios; jmethodID isSmoothZoomSupported; + jmethodID isVideoStabilizationSupported; jmethodID isZoomSupported; jmethodID setAntibanding; jmethodID setColorEffect; @@ -118,6 +120,7 @@ static struct jmethodID setPreviewFpsRange; jmethodID setPreviewSize; jmethodID setSceneMode; + jmethodID setVideoStabilization; jmethodID setWhiteBalance; jmethodID setZoom; jmethodID unflatten; @@ -371,6 +374,8 @@ _init_classes (void) getExposureCompensationStep, "()F"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFlashMode, "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFocalLength, + "()F"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFocusMode, "()Ljava/lang/String;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, @@ -408,6 +413,8 @@ _init_classes (void) getSupportedWhiteBalance, "()Ljava/util/List;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getVerticalViewAngle, "()F"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, getVideoStabilization, + "()Z"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getWhiteBalance, "()Ljava/lang/String;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, getZoom, "()I"); @@ -415,6 +422,8 @@ _init_classes (void) "()Ljava/util/List;"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, isSmoothZoomSupported, "()Z"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, + isVideoStabilizationSupported, "()Z"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, isZoomSupported, "()Z"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setAntibanding, @@ -437,6 +446,8 @@ _init_classes (void) "(Ljava/lang/String;)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setWhiteBalance, "(Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_hardware_camera_parameters, setVideoStabilization, + "(Z)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, setZoom, "(I)V"); GST_DVM_GET_METHOD (android_hardware_camera_parameters, unflatten, "(Ljava/lang/String;)V"); @@ -3034,6 +3045,17 @@ gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self) return angle; } +gboolean +gst_ahc_parameters_get_video_stabilization (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret; + + ret = AHCP_CALL (return FALSE, Boolean, getVideoStabilization); + + return ret; +} + const gchar * gst_ahc_parameters_get_white_balance (GstAHCParameters * self) { @@ -3111,6 +3133,17 @@ gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self) return supported; } +gboolean +gst_ahc_parameters_is_video_stabilization_supported (GstAHCParameters * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean supported; + + supported = AHCP_CALL (return FALSE, Boolean, isVideoStabilizationSupported); + + return supported; +} + gboolean gst_ahc_parameters_is_zoom_supported (GstAHCParameters * self) { @@ -3242,6 +3275,18 @@ gst_ahc_parameters_set_scene_mode (GstAHCParameters * self, const gchar * value) return TRUE; } + +gboolean +gst_ahc_parameters_set_video_stabilization (GstAHCParameters * self, + gboolean toggle) +{ + JNIEnv *env = gst_dvm_get_env (); + + AHCP_CALL (return FALSE, Void, setVideoStabilization, toggle); + + return TRUE; +} + gboolean gst_ahc_parameters_set_white_balance (GstAHCParameters * self, const gchar * value) diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index 6ce80337c3..9e58ac3029 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -204,12 +204,15 @@ void gst_ahc_parameters_supported_scene_modes_free (GList * list); GList *gst_ahc_parameters_get_supported_white_balance (GstAHCParameters * self); void gst_ahc_parameters_supported_white_balance_free (GList * list); gfloat gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self); +gboolean gst_ahc_parameters_get_video_stabilization (GstAHCParameters * self); const gchar *gst_ahc_parameters_get_white_balance (GstAHCParameters * self); gint gst_ahc_parameters_get_zoom (GstAHCParameters * self); /* GList */ GList *gst_ahc_parameters_get_zoom_ratios (GstAHCParameters * self); void gst_ahc_parameters_zoom_ratios_free (GList * list); gboolean gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self); +gboolean gst_ahc_parameters_is_video_stabilization_supported ( + GstAHCParameters * self); gboolean gst_ahc_parameters_is_zoom_supported (GstAHCParameters * self); gboolean gst_ahc_parameters_set_antibanding (GstAHCParameters * self, const gchar * antibanding); @@ -231,6 +234,8 @@ gboolean gst_ahc_parameters_set_scene_mode (GstAHCParameters * self, const gchar * value); gboolean gst_ahc_parameters_set_white_balance (GstAHCParameters * self, const gchar * value); +gboolean gst_ahc_parameters_set_video_stabilization (GstAHCParameters * self, + gboolean toggle); gboolean gst_ahc_parameters_set_zoom (GstAHCParameters * self, gint value); gboolean gst_ahc_parameters_unflatten (GstAHCParameters * self, const gchar * flattened); From 9232685782081553401013774614567461f3497e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 12 Nov 2012 18:19:20 -0500 Subject: [PATCH 57/82] androidcamera: Add focal-length, view-angle and video-stabilization properties --- sys/androidcamera/gstahcsrc.c | 92 +++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 2f7b2e13fb..3211d12865 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -134,6 +134,10 @@ enum PROP_DEVICE, PROP_DEVICE_FACING, PROP_DEVICE_ORIENTATION, + PROP_FOCAL_LENGTH, + PROP_HORIZONTAL_VIEW_ANGLE, + PROP_VERTICAL_VIEW_ANGLE, + PROP_VIDEO_STABILIZATION, PROP_WB_MODE, PROP_COLOUR_TONE, PROP_SCENE_MODE, @@ -268,6 +272,33 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_DEVICE_FACING, properties[PROP_DEVICE_FACING]); + properties[PROP_FOCAL_LENGTH] = g_param_spec_float ("focal-length", + "Focal length", "Gets the focal length (in millimeter) of the camera", + -G_MAXFLOAT, G_MAXFLOAT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_FOCAL_LENGTH, + properties[PROP_FOCAL_LENGTH]); + + properties[PROP_HORIZONTAL_VIEW_ANGLE] = + g_param_spec_float ("horizontal-view-angle", "Horizontal view angle", + "Gets the horizontal angle of view in degrees", + -G_MAXFLOAT, G_MAXFLOAT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_HORIZONTAL_VIEW_ANGLE, + properties[PROP_HORIZONTAL_VIEW_ANGLE]); + + properties[PROP_VERTICAL_VIEW_ANGLE] = + g_param_spec_float ("vertical-view-angle", "Vertical view angle", + "Gets the vertical angle of view in degrees", + -G_MAXFLOAT, G_MAXFLOAT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_VERTICAL_VIEW_ANGLE, + properties[PROP_VERTICAL_VIEW_ANGLE]); + + properties[PROP_VIDEO_STABILIZATION] = + g_param_spec_boolean ("video-stabilization", "Video stabilization", + "Video stabilization reduces the shaking due to the motion of the camera", + FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_VIDEO_STABILIZATION, + properties[PROP_VIDEO_STABILIZATION]); + /* Override GstPhotography properties */ g_object_class_override_property (gobject_class, PROP_WB_MODE, GST_PHOTOGRAPHY_PROP_WB_MODE); @@ -404,6 +435,19 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, self->device = (gint) device; } break; + case PROP_VIDEO_STABILIZATION: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + gst_ahc_parameters_set_video_stabilization (params, + g_value_get_boolean (value)); + gst_ah_camera_set_parameters (self->camera, params); + gst_ahc_parameters_free (params); + } + } + break; case PROP_WB_MODE:{ GstWhiteBalanceMode wb = g_value_get_enum (value); @@ -498,6 +542,54 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, g_value_set_int (value, 0); } break; + case PROP_FOCAL_LENGTH: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + g_value_set_float (value, + gst_ahc_parameters_get_focal_length (params)); + gst_ahc_parameters_free (params); + } + } + break; + case PROP_HORIZONTAL_VIEW_ANGLE: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + g_value_set_float (value, + gst_ahc_parameters_get_horizontal_view_angle (params)); + gst_ahc_parameters_free (params); + } + } + break; + case PROP_VERTICAL_VIEW_ANGLE: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + g_value_set_float (value, + gst_ahc_parameters_get_vertical_view_angle (params)); + gst_ahc_parameters_free (params); + } + } + break; + case PROP_VIDEO_STABILIZATION: + if (self->camera) { + GstAHCParameters *params; + + params = gst_ah_camera_get_parameters (self->camera); + if (params) { + g_value_set_boolean (value, + gst_ahc_parameters_get_video_stabilization (params)); + gst_ahc_parameters_free (params); + } + } + break; case PROP_WB_MODE:{ GstWhiteBalanceMode wb; From 832c7adc76257e0b02b7af3ff8a3d14b596f47f2 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 12 Nov 2012 18:59:57 -0500 Subject: [PATCH 58/82] androidcamera: Add smooth-zoom property for smooth zooming feature --- sys/androidcamera/gstahcsrc.c | 24 ++++++++++++++++++++++-- sys/androidcamera/gstahcsrc.h | 1 + 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 3211d12865..07480c8a3d 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -153,6 +153,7 @@ enum PROP_FLICKER_MODE, PROP_FOCUS_MODE, PROP_ZOOM, + PROP_SMOOTH_ZOOM, PROP_LAST }; @@ -299,6 +300,12 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_VIDEO_STABILIZATION, properties[PROP_VIDEO_STABILIZATION]); + properties[PROP_SMOOTH_ZOOM] = g_param_spec_boolean ("smooth-zoom", + "Smooth Zoom", "Use smooth zoom when available", + FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_SMOOTH_ZOOM, + properties[PROP_SMOOTH_ZOOM]); + /* Override GstPhotography properties */ g_object_class_override_property (gobject_class, PROP_WB_MODE, GST_PHOTOGRAPHY_PROP_WB_MODE); @@ -448,6 +455,9 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, } } break; + case PROP_SMOOTH_ZOOM: + self->smooth_zoom = g_value_get_boolean (value); + break; case PROP_WB_MODE:{ GstWhiteBalanceMode wb = g_value_get_enum (value); @@ -590,6 +600,9 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } } break; + case PROP_SMOOTH_ZOOM: + g_value_set_boolean (value, self->smooth_zoom); + break; case PROP_WB_MODE:{ GstWhiteBalanceMode wb; @@ -1542,8 +1555,15 @@ gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) } if (zoom_idx != -1) { - gst_ahc_parameters_set_zoom (params, zoom_idx); - ret = gst_ah_camera_set_parameters (self->camera, params); + if (self->smooth_zoom && + gst_ahc_parameters_is_smooth_zoom_supported (params)) { + // First, we need to cancel any previous smooth zoom operation + gst_ah_camera_stop_smooth_zoom (self->camera); + ret = gst_ah_camera_start_smooth_zoom (self->camera, zoom_idx); + } else { + gst_ahc_parameters_set_zoom (params, zoom_idx); + ret = gst_ah_camera_set_parameters (self->camera, params); + } } gst_ahc_parameters_zoom_ratios_free (zoom_ratios); diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index 1fe6c52a5b..3b1255722d 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -61,6 +61,7 @@ struct _GstAHCSrc gint fps_min; gint fps_max; gboolean start; + gboolean smooth_zoom; /* Properties */ gint device; From 42ea071c6c9532d914ddc96333eade22f9a01785 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 14 Nov 2012 11:38:51 -0500 Subject: [PATCH 59/82] androidcamera: Do not use gst_list_free_full since it requires glib 2.28 --- sys/androidcamera/gst-android-hardware-camera.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 92dc95d4d6..b8f6a854e5 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -2912,7 +2912,8 @@ gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) void gst_ahc_parameters_supported_preview_fps_range_free (GList * list) { - g_list_free_full (list, (GDestroyNotify) g_free); + g_list_foreach (list, (GFunc) g_free, NULL); + g_list_free (list); } GList * @@ -2955,7 +2956,8 @@ gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self) void gst_ahc_parameters_supported_preview_sizes_free (GList * list) { - g_list_free_full (list, (GDestroyNotify) gst_ahc_size_free); + g_list_foreach (list, (GFunc) gst_ahc_size_free, NULL); + g_list_free (list); } GList * From 0cc2e86492b4474c8b45f570d6deb7a0db4bffc7 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Thu, 15 Nov 2012 12:33:26 -0500 Subject: [PATCH 60/82] androicamera: Make sure the TMP env var exists and check for DEX var too --- sys/androidcamera/gst-android-hardware-camera.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index b8f6a854e5..8e104e79e0 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -1065,7 +1065,7 @@ _init_classes (void) GST_DVM_GET_METHOD (java_lang_integer, intValue, "()I"); /* com.gstreamer.GstAhcCallback */ - if (gst_ahc_callback_jar) { + if (gst_ahc_callback_jar && g_getenv ("TMP")) { jclass dex_loader = NULL; gchar *path = g_strdup_printf ("%s/GstAhcCallback.jar", g_getenv ("TMP")); FILE *fd = fopen (path, "wb"); @@ -1095,7 +1095,10 @@ _init_classes (void) jstring optimized_directory = NULL; dex_path = (*env)->NewStringUTF (env, path); - optimized_directory = (*env)->NewStringUTF (env, g_getenv ("TMP")); + if (g_getenv ("DEX")) + optimized_directory = (*env)->NewStringUTF (env, g_getenv ("DEX")); + else + optimized_directory = (*env)->NewStringUTF (env, g_getenv ("TMP")); (*env)->ExceptionClear (env); if (dex_path && optimized_directory) { jobject loader; From 178ef6e9b784f705c1cc31901d3d88cc93ce4f09 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 19 Nov 2012 18:25:12 -0500 Subject: [PATCH 61/82] androidcamera: Prettify the gstahccallback.c generation line in the makefile --- sys/androidcamera/Makefile.am | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index fa62d7d470..1d832a7057 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -36,12 +36,12 @@ CLEANFILES = gstahccallback.c if HAVE_ANDROID_SDK gstahccallback.c: $(JAVA_SOURCE) - @echo " JAVAC $(JAVA_SOURCE)" + @echo -e " JAVAC\t $(JAVA_SOURCE)" @$(JAVAC) -target 1.6 -source 1.6 -nowarn \ -classpath $(ANDROID_SDK_DIR)/platforms/android-$(ANDROID_PLATFORM)/android.jar $(JAVA_SOURCE) - @echo " DEX $(JAVA_SOURCE:.java=.class)" + @echo -e " DEX\t $(JAVA_SOURCE:.java=.class)" @$(DX) --dex --output GstAhcCallback.jar $(JAVA_SOURCE:.java=.class) - @echo " GEN $@" + @echo -e " GEN\t $@" @echo "#include \"gstahccallback.h\"" > $@ @echo "" >> $@ @echo "const static guint8 jar_file[] = {" >> $@ @@ -53,7 +53,7 @@ gstahccallback.c: $(JAVA_SOURCE) @rm -f GstAhcCallback.jar else gstahccallback.c: - @echo " GEN $@" + @echo -e " GEN\t $@" @echo "#include \"gstahccallback.h\"" > $@ @echo "" >> $@ @echo "const guint8 *gst_ahc_callback_jar = NULL;" >> $@ From ebbf4754374dc46b701d711c244454a1ff544e0e Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 20 Nov 2012 19:56:22 -0500 Subject: [PATCH 62/82] androidcamera: Add element documentation --- docs/plugins/inspect/plugin-androidcamera.xml | 28 ++++++ sys/androidcamera/gstahcsrc.c | 95 +++++++++++++++++++ sys/androidcamera/gstahcsrc.h | 6 ++ 3 files changed, 129 insertions(+) create mode 100644 docs/plugins/inspect/plugin-androidcamera.xml diff --git a/docs/plugins/inspect/plugin-androidcamera.xml b/docs/plugins/inspect/plugin-androidcamera.xml new file mode 100644 index 0000000000..c9417ca974 --- /dev/null +++ b/docs/plugins/inspect/plugin-androidcamera.xml @@ -0,0 +1,28 @@ + + androidcamera + Capture from Android cameras + ../../sys/androidcamera/.libs/libgstandroidcamera.so + libgstandroidcamera.so + 0.10.22.1 + LGPL + gst-plugins-bad + GStreamer Bad Plug-ins git + Unknown package origin + + + ahcsrc + Android Camera Source + Source/Video + Reads frames from android.hardware.Camera class into buffers + Youness Alaoui <youness.alaoui@collabora.co.uk> + + + src + source + always +
video/x-raw-yuv, format=(fourcc) { YV12 , YUY2 , NV21 , NV16 }, width=(int) [ 1, 2147483647 ], height=(int) [ 1, 2147483647 ], framerate=(fraction) [ 0/1, 2147483647/1 ]; video/x-raw-rgb, bpp=(int)16, depth=(int)16, red_mask=(int)63488, green_mask=(int)2016, blue_mask=(int)31, width=(int) [ 1, 2147483647 ], height=(int) [ 1, 2147483647 ], framerate=(fraction) [ 0/1, 2147483647/1 ]
+ + + + + diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 07480c8a3d..311d5683e5 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -19,6 +19,52 @@ * Boston, MA 02111-1307, USA. */ +/** + * SECTION:element-ahcsrc + * + * ahcsrc can be used to capture video from android devices. It uses the + * android.hardware.Camera Java API to capture from the system's cameras. + * + * In order for the plugin to get registered, it must be able to find its + * Java callbacks class. That class is embedded as a jar file inside the source + * element (if properly compiled) and will be written to a temporary directory + * so it can be loaded into the virtual machine. + * In order for it to work, an environment variable must be set to a writable + * directory. + * The source will look for the environment variable “TMP” which must contain + * the absolute path to a writable directory. + * It can be retreived using the following Java code : + * |[ + * context.getCacheDir().getAbsolutePath(); + * ]| + * Where the @context variable is an object of type android.content.Context + * (including its subclasses android.app.Activity or android.app.Application). + * Another optional environment variable can be set for pointing to the + * optimized dex classes directory. If the environment variable “DEX” is + * available, it will be used, otherwise, the directory in the “TMP” environment + * variable will be used for the optimized dex directory. + * The system dex directory can be obtained using the following Java code : + * |[ + * context.getDir(“dex”, 0).getAbsolutePath(); + * ]| + * + * + * Those environment variable must be set before gst_init is called from + * the native code. + * + * + * + * If the “TMP” environment variable is not available or the directory is not + * writable or any other issue happens while trying to load the embedded jar + * file, then the source will fallback on trying to load the class directly + * from the running application. + * The file com/gstreamer/GstAhcCallback.java in the source's directory can be + * copied into the Android application so it can be loaded at runtime + * as a fallback mechanism. + * + * + */ + #ifdef HAVE_CONFIG_H # include "config.h" #endif @@ -254,18 +300,40 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstpushsrc_class->create = gst_ahc_src_create; + /** + * GstAHCSrc:device: + * + * The Device ID of the camera to capture from + */ properties[PROP_DEVICE] = g_param_spec_string ("device", "device", "Device ID", DEFAULT_DEVICE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE, properties[PROP_DEVICE]); + /** + * GstAHCSrc:device-orientation: + * + * The orientation of the currently set camera @device. + * The value is the angle that the camera image needs to be rotated clockwise + * so it shows correctly on the display in its natural orientation. + * It should be 0, 90, 180, or 270. + */ properties[PROP_DEVICE_ORIENTATION] = g_param_spec_int ("device-orientation", "Device orientation", "The orientation of the camera image", 0, 360, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE_ORIENTATION, properties[PROP_DEVICE_ORIENTATION]); + /** + * GstAHCSrc:device-facing: + * + * The direction that the currently select camera @device faces. + * + * A value of 0 means the camera is facing the opposite direction as the + * screen while a value of 1 means the camera is facing the same direction + * as the screen. + */ properties[PROP_DEVICE_FACING] = g_param_spec_enum ("device-facing", "Device facing", "The direction that the camera faces", GST_AHC_SRC_FACING_TYPE, CAMERA_FACING_BACK, @@ -273,12 +341,22 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_DEVICE_FACING, properties[PROP_DEVICE_FACING]); + /** + * GstAHCSrc:focal-length: + * + * Gets the focal length (in millimeter) of the camera. + */ properties[PROP_FOCAL_LENGTH] = g_param_spec_float ("focal-length", "Focal length", "Gets the focal length (in millimeter) of the camera", -G_MAXFLOAT, G_MAXFLOAT, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_FOCAL_LENGTH, properties[PROP_FOCAL_LENGTH]); + /** + * GstAHCSrc:horizontal-view-angle: + * + * Gets the horizontal angle of view in degrees. + */ properties[PROP_HORIZONTAL_VIEW_ANGLE] = g_param_spec_float ("horizontal-view-angle", "Horizontal view angle", "Gets the horizontal angle of view in degrees", @@ -286,6 +364,11 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_HORIZONTAL_VIEW_ANGLE, properties[PROP_HORIZONTAL_VIEW_ANGLE]); + /** + * GstAHCSrc:vertical-view-angle: + * + * Gets the vertical angle of view in degrees. + */ properties[PROP_VERTICAL_VIEW_ANGLE] = g_param_spec_float ("vertical-view-angle", "Vertical view angle", "Gets the vertical angle of view in degrees", @@ -293,6 +376,11 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_VERTICAL_VIEW_ANGLE, properties[PROP_VERTICAL_VIEW_ANGLE]); + /** + * GstAHCSrc:video-stabilizatio: + * + * Video stabilization reduces the shaking due to the motion of the camera. + */ properties[PROP_VIDEO_STABILIZATION] = g_param_spec_boolean ("video-stabilization", "Video stabilization", "Video stabilization reduces the shaking due to the motion of the camera", @@ -300,6 +388,13 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) g_object_class_install_property (gobject_class, PROP_VIDEO_STABILIZATION, properties[PROP_VIDEO_STABILIZATION]); + /** + * GstAHCSrc:smooth-zoom: + * + * If enabled, then smooth zooming will be used when the @zoom property is + * changed. In that case, the @zoom property can be queried to know the + * current zoom level while the smooth zoom is in progress. + */ properties[PROP_SMOOTH_ZOOM] = g_param_spec_boolean ("smooth-zoom", "Smooth Zoom", "Use smooth zoom when available", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidcamera/gstahcsrc.h index 3b1255722d..005cd36704 100644 --- a/sys/androidcamera/gstahcsrc.h +++ b/sys/androidcamera/gstahcsrc.h @@ -45,8 +45,14 @@ G_BEGIN_DECLS typedef struct _GstAHCSrc GstAHCSrc; typedef struct _GstAHCSrcClass GstAHCSrcClass; +/** + * GstAHCSrc: + * + * Opaque data structure. + */ struct _GstAHCSrc { + /*< private >*/ GstPushSrc parent; GstAHCamera *camera; From 5d90cc85cb68ef9720cd44c298b2bac2b361e091 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 27 Nov 2012 17:24:35 -0500 Subject: [PATCH 63/82] androidcamera: Adding a device-name property --- sys/androidcamera/gstahcsrc.c | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 311d5683e5..2ca92cb899 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -178,6 +178,7 @@ enum { PROP_0, PROP_DEVICE, + PROP_DEVICE_NAME, PROP_DEVICE_FACING, PROP_DEVICE_ORIENTATION, PROP_FOCAL_LENGTH, @@ -306,11 +307,22 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) * The Device ID of the camera to capture from */ properties[PROP_DEVICE] = g_param_spec_string ("device", - "device", "Device ID", DEFAULT_DEVICE, + "Device", "Device ID", DEFAULT_DEVICE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); g_object_class_install_property (gobject_class, PROP_DEVICE, properties[PROP_DEVICE]); + /** + * GstAHCSrc:device-name: + * + * A user-friendly name for the camera device + */ + properties[PROP_DEVICE_NAME] = g_param_spec_string ("device-name", + "Device name", "Device name", NULL, + G_PARAM_READABLE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS); + g_object_class_install_property (gobject_class, PROP_DEVICE_NAME, + properties[PROP_DEVICE_NAME]); + /** * GstAHCSrc:device-orientation: * @@ -625,6 +637,19 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, case PROP_DEVICE:{ gchar *dev = g_strdup_printf ("%d", self->device); + g_value_take_string (value, dev); + } + break; + case PROP_DEVICE_NAME:{ + GstAHCCameraInfo info; + gchar *dev; + + if (gst_ah_camera_get_camera_info (self->device, &info)) + dev = g_strdup_printf ("#%d %s", self->device, + info.facing == CameraInfo_CAMERA_FACING_BACK ? "Back" : "Front"); + else + dev = g_strdup_printf ("#%d", self->device); + g_value_take_string (value, dev); } break; From 4a2a73b13faebff621b91c8653abb04df9d79e40 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Tue, 27 Nov 2012 19:25:06 -0500 Subject: [PATCH 64/82] gst-dvm: Create a gst-dvm library using part of androidcamera --- gst-libs/gst/dvm/Makefile.am | 28 +++++++++++++++++++ .../gst/dvm}/gst-dvm.c | 0 .../gst/dvm}/gst-dvm.h | 0 pkgconfig/gstreamer-dvm-uninstalled.pc.in | 12 ++++++++ pkgconfig/gstreamer-dvm.pc.in | 12 ++++++++ sys/androidcamera/Makefile.am | 2 -- .../gst-android-graphics-imageformat.c | 3 +- .../gst-android-graphics-surfacetexture.c | 3 +- .../gst-android-hardware-camera.c | 3 +- sys/androidcamera/gst-androidcamera.c | 2 +- sys/androidcamera/gstahcsrc.c | 2 +- 11 files changed, 60 insertions(+), 7 deletions(-) create mode 100644 gst-libs/gst/dvm/Makefile.am rename {sys/androidcamera => gst-libs/gst/dvm}/gst-dvm.c (100%) rename {sys/androidcamera => gst-libs/gst/dvm}/gst-dvm.h (100%) create mode 100644 pkgconfig/gstreamer-dvm-uninstalled.pc.in create mode 100644 pkgconfig/gstreamer-dvm.pc.in diff --git a/gst-libs/gst/dvm/Makefile.am b/gst-libs/gst/dvm/Makefile.am new file mode 100644 index 0000000000..d2f4d2abad --- /dev/null +++ b/gst-libs/gst/dvm/Makefile.am @@ -0,0 +1,28 @@ +lib_LTLIBRARIES = libgstdvm-@GST_MAJORMINOR@.la +libgstdvmincludedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/dvm + +libgstdvminclude_HEADERS = \ + gst-dvm.h + +libgstdvm_@GST_MAJORMINOR@_la_SOURCES = \ + gst-dvm.c + +libgstdvm_@GST_MAJORMINOR@_la_CFLAGS = \ + $(GST_PLUGINS_BAD_CFLAGS) \ + $(GST_CFLAGS) +libgstdvm_@GST_MAJORMINOR@_la_LIBADD = $(GST_LIBS) +libgstdvm_@GST_MAJORMINOR@_la_LDFLAGS = $(GST_LIB_LDFLAGS) $(GST_ALL_LDFLAGS) $(GST_LT_LDFLAGS) + +Android.mk: $(BUILT_SOURCES) Makefile.am + androgenizer -:PROJECT libgstdvm -:STATIC libgstdvm-@GST_MAJORMINOR@ \ + -:TAGS eng debug \ + -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \ + -:SOURCES $(libgstdvm_@GST_MAJORMINOR@_la_SOURCES) \ + -:CFLAGS $(DEFS) $(libgstdvm_@GST_MAJORMINOR@_la_CFLAGS) \ + -:LDFLAGS $(libgstdvm_@GST_MAJORMINOR@_la_LDFLAGS) \ + $(libgstdvm_@GST_MAJORMINOR@_la_LIBADD) \ + -ldl \ + -:HEADER_TARGET gstreamer-@GST_MAJORMINOR@/gst/dvm \ + -:HEADERS $(libgstdvminclude_HEADERS) + -:PASSTHROUGH LOCAL_ARM_MODE:=arm \ + > $@ diff --git a/sys/androidcamera/gst-dvm.c b/gst-libs/gst/dvm/gst-dvm.c similarity index 100% rename from sys/androidcamera/gst-dvm.c rename to gst-libs/gst/dvm/gst-dvm.c diff --git a/sys/androidcamera/gst-dvm.h b/gst-libs/gst/dvm/gst-dvm.h similarity index 100% rename from sys/androidcamera/gst-dvm.h rename to gst-libs/gst/dvm/gst-dvm.h diff --git a/pkgconfig/gstreamer-dvm-uninstalled.pc.in b/pkgconfig/gstreamer-dvm-uninstalled.pc.in new file mode 100644 index 0000000000..c1de57e9bf --- /dev/null +++ b/pkgconfig/gstreamer-dvm-uninstalled.pc.in @@ -0,0 +1,12 @@ +prefix= +exec_prefix= +libdir=${pcfiledir}/../gst-libs/gst/dvm +includedir=${pcfiledir}/../gst-libs + +Name: GStreamer DVM, Uninstalled +Description: Dalvik Virtual Machine helpers, Uninstalled +Requires: gstreamer-@GST_MAJORMINOR@ +Version: @VERSION@ +Libs: -L${libdir} ${libdir}/libgstdvm-@GST_MAJORMINOR@.la +Cflags: -I${includedir} + diff --git a/pkgconfig/gstreamer-dvm.pc.in b/pkgconfig/gstreamer-dvm.pc.in new file mode 100644 index 0000000000..a3203a5fd1 --- /dev/null +++ b/pkgconfig/gstreamer-dvm.pc.in @@ -0,0 +1,12 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@/gstreamer-@GST_MAJORMINOR@ + +Name: GStreamer DVM +Description: Dalvik Virtual Machine helpers +Requires: gstreamer-@GST_MAJORMINOR@ +Version: @VERSION@ +Libs: -L${libdir} -lgstdvm-@GST_MAJORMINOR@ +Cflags: -I${includedir} + diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index 1d832a7057..f2a6ac5e2b 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -2,7 +2,6 @@ plugin_LTLIBRARIES = libgstandroidcamera.la libgstandroidcamera_la_SOURCES = \ gst-androidcamera.c \ - gst-dvm.c \ gst-android-hardware-camera.c \ gst-android-graphics-surfacetexture.c \ gst-android-graphics-imageformat.c \ @@ -12,7 +11,6 @@ libgstandroidcamera_la_SOURCES = \ JAVA_SOURCE = com/gstreamer/GstAhcCallback.java noinst_HEADERS = \ - gst-dvm.h \ gstahcsrc.h \ gstahccallback.h \ gst-android-hardware-camera.h \ diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c index afa724ef06..3140af048e 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.c +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -23,7 +23,8 @@ #include "config.h" #endif -#include "gst-dvm.h" +#include + #include "gst-android-graphics-imageformat.h" diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index a532ec9ea1..bb78f0273c 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -23,7 +23,8 @@ #include "config.h" #endif -#include "gst-dvm.h" +#include + #include "gst-android-graphics-surfacetexture.h" diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 8e104e79e0..945c6e6cf4 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -23,7 +23,8 @@ #include "config.h" #endif -#include "gst-dvm.h" +#include + #include "gstahccallback.h" #include "gst-android-hardware-camera.h" #include "stdio.h" diff --git a/sys/androidcamera/gst-androidcamera.c b/sys/androidcamera/gst-androidcamera.c index 68c6a6be4b..6aa2d412c0 100644 --- a/sys/androidcamera/gst-androidcamera.c +++ b/sys/androidcamera/gst-androidcamera.c @@ -23,8 +23,8 @@ #endif #include +#include -#include "gst-dvm.h" #include "gst-android-hardware-camera.h" #include "gstahcsrc.h" diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 2ca92cb899..6f8f056e92 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -73,9 +73,9 @@ #include #include #include +#include #include "gstahcsrc.h" -#include "gst-dvm.h" /* GObject */ static void gst_ahc_src_set_property (GObject * object, guint prop_id, From eb949625b92fd5ac2ea417d5564dc6f588784b8b Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 28 Nov 2012 15:26:49 -0500 Subject: [PATCH 65/82] androidcamera: Add G_BEGIN/END_DECLS to the .h --- sys/androidcamera/gst-android-graphics-imageformat.h | 2 ++ sys/androidcamera/gst-android-graphics-surfacetexture.h | 3 +++ sys/androidcamera/gst-android-hardware-camera.h | 3 +++ 3 files changed, 8 insertions(+) diff --git a/sys/androidcamera/gst-android-graphics-imageformat.h b/sys/androidcamera/gst-android-graphics-imageformat.h index 84b48f8af6..257a30408f 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.h +++ b/sys/androidcamera/gst-android-graphics-imageformat.h @@ -26,6 +26,7 @@ #include +G_BEGIN_DECLS /* android.graphics.ImageFormat */ extern gint ImageFormat_JPEG; @@ -41,6 +42,7 @@ void gst_android_graphics_imageformat_deinit (void); gint gst_ag_imageformat_get_bits_per_pixel (gint format); +G_END_DECLS #endif /* __GST_ANDROID_GRAPHICS_IMAGEFORMAT_H__ */ diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.h b/sys/androidcamera/gst-android-graphics-surfacetexture.h index 7938e3e8fe..6ed04d8642 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.h +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.h @@ -26,6 +26,8 @@ #include +G_BEGIN_DECLS + typedef struct _GstAGSurfaceTexture GstAGSurfaceTexture; /* android.graphics.SurfaceTexture */ @@ -42,6 +44,7 @@ void gst_android_graphics_surfacetexture_deinit (void); GstAGSurfaceTexture *gst_ag_surfacetexture_new (gint texture_id); void gst_ag_surfacetexture_release (GstAGSurfaceTexture *self); +G_END_DECLS #endif /* __GST_ANDROID_GRAPHICS_SURFACETEXTURE_H__ */ diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index 9e58ac3029..aeffe71d63 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -28,6 +28,8 @@ #include "gst-android-graphics-surfacetexture.h" #include "gst-android-graphics-imageformat.h" +G_BEGIN_DECLS + typedef struct _GstAHCamera GstAHCamera; typedef struct _GstAHCCameraInfo GstAHCCameraInfo; typedef struct _GstAHCSize GstAHCSize; @@ -241,5 +243,6 @@ gboolean gst_ahc_parameters_unflatten (GstAHCParameters * self, const gchar * flattened); void gst_ahc_parameters_free (GstAHCParameters * self); +G_END_DECLS #endif /* __GST_ANDROID_HARDWARE_CAMERA_H__ */ From 3ac90867acd483d0de4b916ba8096f7f3d686d33 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Wed, 28 Nov 2012 20:53:51 -0500 Subject: [PATCH 66/82] androidmedia: Use gst-dvm and refactor java wrappers (WIP) Moved the java wrapper API into its own files and made use of the gst-dvm macros. Also renamed the API to have the proper naming convention and coding style in order to match the one in androidcamera. This is a work in progress! "android/media/MediaCodecList" is still missing and the actual elements have not been ported to use the new function names. --- .../gst-android-media-mediacodec.c | 533 ++++++++++++++++ .../gst-android-media-mediacodec.h | 89 +++ .../gst-android-media-mediaformat.c | 602 ++++++++++++++++++ .../gst-android-media-mediaformat.h | 75 +++ 4 files changed, 1299 insertions(+) create mode 100644 sys/androidmedia/gst-android-media-mediacodec.c create mode 100644 sys/androidmedia/gst-android-media-mediacodec.h create mode 100644 sys/androidmedia/gst-android-media-mediaformat.c create mode 100644 sys/androidmedia/gst-android-media-mediaformat.h diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c new file mode 100644 index 0000000000..9e9bd2451b --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -0,0 +1,533 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gst-android-media-mediacodec.h" + + +static struct +{ + jclass klass; + jmethodID constructor; + jfieldID flags; + jfieldID offset; + jfieldID presentationTimeUs; + jfieldID size; +} android_media_mediacodec_bufferinfo; + +static struct +{ + jclass klass; + jmethodID configure; + jmethodID createByCodecName; + jmethodID createDecoderByType; + jmethodID createEncoderByType; + jmethodID dequeueInputBuffer; + jmethodID dequeueOutputBuffer; + jmethodID flush; + jmethodID getInputBuffers; + jmethodID getOutputBuffers; + jmethodID getOutputFormat; + jmethodID queueInputBuffer; + jmethodID release; + jmethodID releaseOutputBuffer; + jmethodID start; + jmethodID stop; +} android_media_mediacodec = { +0}; + + + +static gboolean +_init_classes (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.media.MediaCodec */ + GST_DVM_GET_CLASS (android_media_mediacodec, "android/media/MediaCodec"); + GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createByCodecName, + "(Ljava/lang/String;)Landroid/media/MediaCodec;"); + GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createDecoderByType, + "(Ljava/lang/String;)Landroid/media/MediaCodec;"); + GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createEncoderByType, + "(Ljava/lang/String;)Landroid/media/MediaCodec;"); + GST_DVM_GET_METHOD (android_media_mediacodec, configure, + "(Landroid/media/MediaFormat;Landroid/view/Surface;" + "Landroid/media/MediaCrypto;I)V"); + GST_DVM_GET_METHOD (android_media_mediacodec, dequeueInputBuffer, "(J)I"); + GST_DVM_GET_METHOD (android_media_mediacodec, dequeueOutputBuffer, + "(Landroid/media/MediaCodec$BufferInfo;J)I"); + GST_DVM_GET_METHOD (android_media_mediacodec, flush, "()V"); + GST_DVM_GET_METHOD (android_media_mediacodec, getInputBuffers, + "()[Ljava/nio/ByteBuffer;"); + GST_DVM_GET_METHOD (android_media_mediacodec, getOutputBuffers, + "()[Ljava/nio/ByteBuffer;"); + GST_DVM_GET_METHOD (android_media_mediacodec, getOutputFormat, + "()Landroid/media/MediaFormat;"); + GST_DVM_GET_METHOD (android_media_mediacodec, queueInputBuffer, "(IIIJI)V"); + GST_DVM_GET_METHOD (android_media_mediacodec, release, "()V"); + GST_DVM_GET_METHOD (android_media_mediacodec, releaseOutputBuffer, "(IZ)V"); + GST_DVM_GET_METHOD (android_media_mediacodec, start, "()V"); + GST_DVM_GET_METHOD (android_media_mediacodec, stop, "()V"); + + /* android.media.MediaCodec.BufferInfo */ + GST_DVM_GET_CLASS (android_media_mediacodec_bufferinfo, + "android/media/MediaCodec$BufferInfo"); + GST_DVM_GET_CONSTRUCTOR (android_media_mediacodec_bufferinfo, constructor, + "()V"); + GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, flags, "I"); + GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, offset, "I"); + GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, presentationTimeUs, + "J"); + GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, size, "I"); + + return TRUE; +} + +gboolean +gst_android_media_mediacodec_init (void) +{ + if (!_init_classes ()) { + gst_android_media_mediacodec_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_media_mediacodec_deinit (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_media_mediacodec.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodec.klass); + android_media_mediacodec.klass = NULL; + + if (android_media_mediacodec_bufferinfo.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodec_bufferinfo.klass); + android_media_mediacodec_bufferinfo.klass = NULL; +} + +/* android.media.MediaCodec */ + +#define AMMC_CALL(error_statement, type, method, ...) \ + GST_DVM_CALL (error_statement, self->object, type, \ + android_media_mediacodec, method, ## __VA_ARGS__); +#define AMMC_STATIC_CALL(error_statement, type, method, ...) \ + GST_DVM_STATIC_CALL (error_statement, type, \ + android_media_mediacodec, method, ## __VA_ARGS__); + +gboolean +gst_am_mediacodec_configure (GstAmMediaCodec * self, GstAmMediaFormat * format, + gint flags) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (format != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, configure, format->object, NULL, NULL, flags); + + return TRUE; +} + +GstAmMediaCodec * +gst_am_mediacodec_create_by_codec_name (const gchar * name) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaCodec *codec = NULL; + jobject object = NULL; + jstring name_str; + + g_return_val_if_fail (name != NULL, NULL); + + name_str = (*env)->NewStringUTF (env, name); + if (name_str == NULL) + goto done; + + object = AMMC_STATIC_CALL (goto done, Object, createByCodecName, name_str); + if (object) { + codec = g_slice_new0 (GstAmMediaCodec); + codec->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!codec->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaCodec, codec); + codec = NULL; + } + } + +done: + if (name_str) + (*env)->DeleteLocalRef (env, name_str); + + return codec; +} + + +GstAmMediaFormat * +gst_am_mediacodec_get_output_format (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaFormat *format = NULL; + jobject object = NULL; + + g_return_val_if_fail (self != NULL, NULL); + + object = AMMC_CALL (return NULL, Object, getOutputFormat); + if (object) { + format = g_slice_new0 (GstAmMediaFormat); + format->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!format->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaFormat, format); + return NULL; + } + } + + return format; +} + +gboolean +gst_am_mediacodec_start (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, start); + + return TRUE; +} + +gboolean +gst_am_mediacodec_stop (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, stop); + + return TRUE; +} + +gboolean +gst_am_mediacodec_flush (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, flush); + + return TRUE; +} + +void +gst_am_mediacodec_release (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_if_fail (self != NULL); + + AMMC_CALL (, Void, release); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAmMediaCodec, self); +} + +void +gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers) +{ + JNIEnv *env = gst_dvm_get_env (); + jsize i; + + g_return_if_fail (buffers != NULL); + + for (i = 0; i < n_buffers; i++) { + if (buffers[i].object) + (*env)->DeleteGlobalRef (env, buffers[i].object); + } + g_free (buffers); +} + +GstAmcBuffer * +gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject output_buffers = NULL; + jsize n_output_buffers; + GstAmcBuffer *ret = NULL; + jsize i; + + g_return_val_if_fail (self != NULL, NULL); + g_return_val_if_fail (n_buffers != NULL, NULL); + + *n_buffers = 0; + output_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); + if (!output_buffers) + goto done; + + n_output_buffers = (*env)->GetArrayLength (env, output_buffers); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get output buffers array length"); + goto done; + } + + *n_buffers = n_output_buffers; + ret = g_new0 (GstAmcBuffer, n_output_buffers); + + for (i = 0; i < n_output_buffers; i++) { + jobject buffer = NULL; + + buffer = (*env)->GetObjectArrayElement (env, output_buffers, i); + if ((*env)->ExceptionCheck (env) || !buffer) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get output buffer %d", i); + goto error; + } + + ret[i].object = (*env)->NewGlobalRef (env, buffer); + (*env)->DeleteLocalRef (env, buffer); + if (!ret[i].object) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to create global reference %d", i); + goto error; + } + + ret[i].data = (*env)->GetDirectBufferAddress (env, ret[i].object); + if (!ret[i].data) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer address %d", i); + goto error; + } + ret[i].size = (*env)->GetDirectBufferCapacity (env, ret[i].object); + } + +done: + if (output_buffers) + (*env)->DeleteLocalRef (env, output_buffers); + output_buffers = NULL; + + return ret; +error: + if (ret) + gst_am_mediacodec_free_buffers (ret, n_output_buffers); + ret = NULL; + *n_buffers = 0; + goto done; +} + +GstAmcBuffer * +gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject input_buffers = NULL; + jsize n_input_buffers; + GstAmcBuffer *ret = NULL; + jsize i; + + g_return_val_if_fail (self != NULL, NULL); + g_return_val_if_fail (n_buffers != NULL, NULL); + + *n_buffers = 0; + + input_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); + if (!input_buffers) + goto done; + + n_input_buffers = (*env)->GetArrayLength (env, input_buffers); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get input buffers array length"); + goto done; + } + + *n_buffers = n_input_buffers; + ret = g_new0 (GstAmcBuffer, n_input_buffers); + + for (i = 0; i < n_input_buffers; i++) { + jobject buffer = NULL; + + buffer = (*env)->GetObjectArrayElement (env, input_buffers, i); + if ((*env)->ExceptionCheck (env) || !buffer) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get input buffer %d", i); + goto error; + } + + ret[i].object = (*env)->NewGlobalRef (env, buffer); + (*env)->DeleteLocalRef (env, buffer); + if (!ret[i].object) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to create global reference %d", i); + goto error; + } + + ret[i].data = (*env)->GetDirectBufferAddress (env, ret[i].object); + if (!ret[i].data) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer address %d", i); + goto error; + } + ret[i].size = (*env)->GetDirectBufferCapacity (env, ret[i].object); + } + +done: + if (input_buffers) + (*env)->DeleteLocalRef (env, input_buffers); + input_buffers = NULL; + + return ret; +error: + if (ret) + gst_am_mediacodec_free_buffers (ret, n_input_buffers); + ret = NULL; + *n_buffers = 0; + goto done; +} + +gint +gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, + gint64 timeoutUs) +{ + JNIEnv *env = gst_dvm_get_env (); + gint ret = G_MININT; + + g_return_val_if_fail (self != NULL, G_MININT); + + ret = AMMC_CALL (return G_MININT, Int, dequeueInputBuffer, timeoutUs); + + return ret; +} + +static gboolean +_fill_buffer_info (JNIEnv * env, jobject buffer_info, GstAmmcBufferInfo * info) +{ + g_return_val_if_fail (buffer_info != NULL, FALSE); + + info->flags = (*env)->GetIntField (env, buffer_info, + android_media_mediacodec_bufferinfo.flags); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer info field"); + return FALSE; + } + + info->offset = (*env)->GetIntField (env, buffer_info, + android_media_mediacodec_bufferinfo.offset); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer info field"); + return FALSE; + } + + info->presentation_time_us = (*env)->GetLongField (env, buffer_info, + android_media_mediacodec_bufferinfo.presentationTimeUs); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer info field"); + return FALSE; + } + + info->size = (*env)->GetIntField (env, buffer_info, + android_media_mediacodec_bufferinfo.size); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer info field"); + return FALSE; + } + + return TRUE; +} + +gint +gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, + GstAmmcBufferInfo * info, gint64 timeoutUs) +{ + JNIEnv *env = gst_dvm_get_env (); + gint ret = G_MININT; + jobject info_o = NULL; + + g_return_val_if_fail (self != NULL, G_MININT); + + info_o = (*env)->NewObject (env, android_media_mediacodec_bufferinfo.klass, + android_media_mediacodec_bufferinfo.constructor); + if (!info_o) { + GST_ERROR ("Failed to call Java method"); + (*env)->ExceptionClear (env); + goto done; + } + + ret = AMMC_CALL (goto error, Int, dequeueOutputBuffer, info_o, timeoutUs); + + if (!_fill_buffer_info (env, info_o, info)) + goto error; + +done: + if (info_o) + (*env)->DeleteLocalRef (env, info_o); + info_o = NULL; + + return ret; + +error: + ret = G_MININT; + goto done; +} + +gboolean +gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, gint index, + const GstAmmcBufferInfo * info) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (info != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, queueInputBuffer, index, info->offset, + info->size, info->presentation_time_us, info->flags); + + return TRUE; +} + +gboolean +gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, gint index) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_val_if_fail (self != NULL, FALSE); + + AMMC_CALL (return FALSE, Void, releaseOutputBuffer, index, JNI_FALSE); + + return TRUE; +} diff --git a/sys/androidmedia/gst-android-media-mediacodec.h b/sys/androidmedia/gst-android-media-mediacodec.h new file mode 100644 index 0000000000..4e242615d7 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodec.h @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_MEDIA_MEDIACODEC_H__ +#define __GST_ANDROID_MEDIA_MEDIACODEC_H__ + +#include +#include + +#include "gst-android-media-mediaformat.h" + +G_BEGIN_DECLS + +typedef struct _GstAmcBuffer GstAmcBuffer; +typedef struct _GstAmmcBufferInfo GstAmmcBufferInfo; +typedef struct _GstAmMediaCodec GstAmMediaCodec; + +struct _GstAmcBuffer { + guint8 *data; + gsize size; + /*< private >*/ + jobject object; /* global reference */ +}; + +struct _GstAmmcBufferInfo { + gint flags; + gint offset; + gint64 presentation_time_us; + gint size; +}; + +struct _GstAmMediaCodec { + /*< private >*/ + jobject object; /* global reference */ +}; + +gboolean gst_android_media_mediacodec_init (void); +void gst_android_media_mediacodec_deinit (void); + +gboolean gst_am_mediacodec_configure (GstAmMediaCodec * self, + GstAmMediaFormat * format, gint flags); + +GstAmMediaCodec * gst_am_mediacodec_create_by_codec_name (const gchar *name); +GstAmMediaCodec * gst_am_mediacodec_create_decoder_by_type (const gchar *type); +GstAmMediaCodec * gst_am_mediacodec_create_encoder_by_type (const gchar *type); + +gint gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, + gint64 timeoutUs); +gint gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, + GstAmmcBufferInfo *info, gint64 timeoutUs); +gboolean gst_am_mediacodec_flush (GstAmMediaCodec * self); + +GstAmcBuffer * gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, + gsize * n_buffers); +GstAmcBuffer * gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, + gsize * n_buffers); +void gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers); +GstAmMediaFormat * gst_am_mediacodec_get_output_format (GstAmMediaCodec * self); + +gboolean gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, + gint index, const GstAmmcBufferInfo *info); +void gst_am_mediacodec_release (GstAmMediaCodec * self); +gboolean gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, + gint index); + +gboolean gst_am_mediacodec_start (GstAmMediaCodec * self); +gboolean gst_am_mediacodec_stop (GstAmMediaCodec * self); + +G_END_DECLS + +#endif /* __GST_ANDROID_MEDIA_MEDIACODEC_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediaformat.c b/sys/androidmedia/gst-android-media-mediaformat.c new file mode 100644 index 0000000000..e4e9eadb34 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediaformat.c @@ -0,0 +1,602 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gst-android-media-mediaformat.h" + +static struct +{ + jclass klass; + jmethodID constructor; + jmethodID containsKey; + jmethodID createAudioFormat; + jmethodID createVideoFormat; + jmethodID getByteBuffer; + jmethodID getFloat; + jmethodID getInteger; + jmethodID getLong; + jmethodID getString; + jmethodID setByteBuffer; + jmethodID setFloat; + jmethodID setInteger; + jmethodID setLong; + jmethodID setString; + jmethodID toString; +} android_media_mediaformat; + + +static gboolean +_init_classes (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.media.MediaFormat */ + GST_DVM_GET_CLASS (android_media_mediaformat, "android/media/MediaFormat"); + GST_DVM_GET_CONSTRUCTOR (android_media_mediaformat, constructor, "()V"); + GST_DVM_GET_STATIC_METHOD (android_media_mediaformat, createAudioFormat, + "(Ljava/lang/String;II)Landroid/media/MediaFormat;"); + GST_DVM_GET_STATIC_METHOD (android_media_mediaformat, createVideoFormat, + "(Ljava/lang/String;II)Landroid/media/MediaFormat;"); + GST_DVM_GET_METHOD (android_media_mediaformat, toString, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_media_mediaformat, containsKey, + "(Ljava/lang/String;)Z"); + GST_DVM_GET_METHOD (android_media_mediaformat, getFloat, + "(Ljava/lang/String;)F"); + GST_DVM_GET_METHOD (android_media_mediaformat, setFloat, + "(Ljava/lang/String;F)V"); + GST_DVM_GET_METHOD (android_media_mediaformat, getInteger, + "(Ljava/lang/String;)I"); + GST_DVM_GET_METHOD (android_media_mediaformat, setInteger, + "(Ljava/lang/String;I)V"); + GST_DVM_GET_METHOD (android_media_mediaformat, getLong, + "(Ljava/lang/String;)J"); + GST_DVM_GET_METHOD (android_media_mediaformat, setLong, + "(Ljava/lang/String;J)V"); + GST_DVM_GET_METHOD (android_media_mediaformat, getString, + "(Ljava/lang/String;)Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_media_mediaformat, setString, + "(Ljava/lang/String;Ljava/lang/String;)V"); + GST_DVM_GET_METHOD (android_media_mediaformat, getByteBuffer, + "(Ljava/lang/String;)Ljava/nio/ByteBuffer;"); + GST_DVM_GET_METHOD (android_media_mediaformat, setByteBuffer, + "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V"); + + return TRUE; +} + +gboolean +gst_android_media_mediaformat_init (void) +{ + if (!_init_classes ()) { + gst_android_media_mediaformat_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_media_mediaformat_deinit (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_media_mediaformat.klass) + (*env)->DeleteGlobalRef (env, android_media_mediaformat.klass); + android_media_mediaformat.klass = NULL; +} + +/* android.media.MediaFormat */ +#define AMMF_CALL(error_statement, type, method, ...) \ + GST_DVM_CALL (error_statement, self->object, type, \ + android_media_mediaformat, method, ## __VA_ARGS__); +#define AMMF_STATIC_CALL(error_statement, type, method, ...) \ + GST_DVM_STATIC_CALL (error_statement, type, \ + android_media_mediaformat, method, ## __VA_ARGS__); + +GstAmMediaFormat * +gst_am_mediaformat_new (void) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaFormat *format = NULL; + jobject object = NULL; + + object = (*env)->NewObject (env, android_media_mediaformat.klass, + android_media_mediaformat.constructor); + if ((*env)->ExceptionCheck (env) || !object) { + GST_ERROR ("Failed to create callback object"); + (*env)->ExceptionClear (env); + return NULL; + } + + format = g_slice_new0 (GstAmMediaFormat); + format->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!format->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaFormat, format); + return NULL; + } + + return format; +} + +GstAmMediaFormat * +gst_am_mediaformat_create_audio_format (const gchar * mime, + gint sample_rate, gint channels) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaFormat *format = NULL; + jstring mime_str; + jobject object = NULL; + + g_return_val_if_fail (mime != NULL, NULL); + + mime_str = (*env)->NewStringUTF (env, mime); + if (mime_str == NULL) + goto done; + + object = AMMF_STATIC_CALL (goto done, Object, createAudioFormat, mime_str, + sample_rate, channels); + if (object) { + format = g_slice_new0 (GstAmMediaFormat); + format->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!format->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaFormat, format); + format = NULL; + } + } + +done: + if (mime_str) + (*env)->DeleteLocalRef (env, mime_str); + + return format; +} + +GstAmMediaFormat * +gst_am_mediaformat_create_video_format (const gchar * mime, + gint width, gint height) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaFormat *format = NULL; + jstring mime_str; + jobject object = NULL; + + g_return_val_if_fail (mime != NULL, NULL); + + mime_str = (*env)->NewStringUTF (env, mime); + if (mime_str == NULL) + goto done; + + object = AMMF_STATIC_CALL (goto done, Object, createVideoFormat, mime_str, + width, height); + if (object) { + format = g_slice_new0 (GstAmMediaFormat); + format->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!format->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaFormat, format); + format = NULL; + } + } + +done: + if (mime_str) + (*env)->DeleteLocalRef (env, mime_str); + + return format; +} + +void +gst_am_mediaformat_free (GstAmMediaFormat * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + g_return_if_fail (self != NULL); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAmMediaFormat, self); +} + +gchar * +gst_am_mediaformat_to_string (GstAmMediaFormat * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring v_str = NULL; + const gchar *v = NULL; + gchar *ret = NULL; + + g_return_val_if_fail (self != NULL, FALSE); + + v_str = AMMF_CALL (return NULL, Object, toString); + if (v_str) { + v = (*env)->GetStringUTFChars (env, v_str, NULL); + if (!v) { + GST_ERROR ("Failed to convert string to UTF8"); + (*env)->ExceptionClear (env); + goto done; + } + ret = g_strdup (v); + } + +done: + if (v) + (*env)->ReleaseStringUTFChars (env, v_str, v); + if (v_str) + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +gboolean +gst_am_mediaformat_contains_key (GstAmMediaFormat * self, const gchar * key) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = FALSE; + jstring key_str = NULL; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + ret = AMMF_CALL (ret = FALSE; goto done, Boolean, containsKey, key_str); + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; +} + +gboolean +gst_am_mediaformat_get_float (GstAmMediaFormat * self, const gchar * key, + gfloat * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + *value = 0; + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + *value = AMMF_CALL (goto done, Float, getFloat, key_str); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; +} + +gboolean +gst_am_mediaformat_set_float (GstAmMediaFormat * self, const gchar * key, + gfloat value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + AMMF_CALL (goto done, Void, setFloat, key_str, value); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; +} + +gboolean +gst_am_mediaformat_get_int (GstAmMediaFormat * self, const gchar * key, + gint * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + *value = 0; + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + *value = AMMF_CALL (goto done, Int, getInteger, key_str); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; + +} + +gboolean +gst_am_mediaformat_set_int (GstAmMediaFormat * self, const gchar * key, + gint value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + AMMF_CALL (goto done, Void, setInteger, key_str, value); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; +} + +gboolean +gst_am_mediaformat_get_long (GstAmMediaFormat * self, const gchar * key, + glong * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + jlong long_value; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + *value = 0; + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + long_value = AMMF_CALL (goto done, Long, getLong, key_str); + *value = long_value; + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; + +} + +gboolean +gst_am_mediaformat_set_long (GstAmMediaFormat * self, const gchar * key, + glong value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + gboolean ret = FALSE; + jlong long_value = value; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + AMMF_CALL (goto done, Void, setLong, key_str, long_value); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + + return ret; +} + +gboolean +gst_am_mediaformat_get_string (GstAmMediaFormat * self, const gchar * key, + gchar ** value) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = FALSE; + jstring key_str = NULL; + jstring v_str = NULL; + const gchar *v = NULL; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + *value = 0; + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + v_str = AMMF_CALL (goto done, Object, getString, key_str); + + v = (*env)->GetStringUTFChars (env, v_str, NULL); + if (!v) { + GST_ERROR ("Failed to convert string to UTF8"); + (*env)->ExceptionClear (env); + goto done; + } + + *value = g_strdup (v); + + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + if (v) + (*env)->ReleaseStringUTFChars (env, v_str, v); + if (v_str) + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +gboolean +gst_am_mediaformat_set_string (GstAmMediaFormat * self, const gchar * key, + const gchar * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + jstring v_str = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + v_str = (*env)->NewStringUTF (env, value); + if (!v_str) + goto done; + + AMMF_CALL (goto done, Void, setString, key_str, v_str); + ret = TRUE; +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + if (v_str) + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +gboolean +gst_am_mediaformat_get_buffer (GstAmMediaFormat * self, const gchar * key, + GstBuffer ** value) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = FALSE; + jstring key_str = NULL; + jobject v = NULL; + guint8 *data; + gsize size; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + *value = 0; + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + v = AMMF_CALL (goto done, Object, getByteBuffer, key_str); + + data = (*env)->GetDirectBufferAddress (env, v); + if (!data) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get buffer address"); + goto done; + } + size = (*env)->GetDirectBufferCapacity (env, v); + *value = gst_buffer_new_and_alloc (size); + memcpy (GST_BUFFER_DATA (*value), data, size); + + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + if (v) + (*env)->DeleteLocalRef (env, v); + + return ret; +} + +gboolean +gst_am_mediaformat_set_buffer (GstAmMediaFormat * self, const gchar * key, + GstBuffer * value) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring key_str = NULL; + jobject v = NULL; + gboolean ret = FALSE; + + g_return_val_if_fail (self != NULL, FALSE); + g_return_val_if_fail (key != NULL, FALSE); + g_return_val_if_fail (value != NULL, FALSE); + + + key_str = (*env)->NewStringUTF (env, key); + if (!key_str) + goto done; + + /* FIXME: The buffer must remain valid until the codec is stopped */ + v = (*env)->NewDirectByteBuffer (env, GST_BUFFER_DATA (value), + GST_BUFFER_SIZE (value)); + if (!v) + goto done; + + AMMF_CALL (goto done, Void, setByteBuffer, key_str, v); + ret = TRUE; + +done: + if (key_str) + (*env)->DeleteLocalRef (env, key_str); + if (v) + (*env)->DeleteLocalRef (env, v); + + return ret; +} diff --git a/sys/androidmedia/gst-android-media-mediaformat.h b/sys/androidmedia/gst-android-media-mediaformat.h new file mode 100644 index 0000000000..28158fccb1 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediaformat.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ +#define __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ + +#include +#include + +typedef struct _GstAmMediaFormat GstAmMediaFormat; + +struct _GstAmMediaFormat { + /*< private >*/ + jobject object; /* global reference */ +}; + +G_BEGIN_DECLS + +gboolean gst_android_media_mediaformat_init (void); +void gst_android_media_mediaformat_deinit (void); + +GstAmMediaFormat * gst_am_mediaformat_new (void); +GstAmMediaFormat * gst_am_mediaformat_create_audio_format (const gchar *mime, + gint sample_rate, gint channels); +GstAmMediaFormat * gst_am_mediaformat_create_video_format (const gchar *mime, + gint width, gint height); +void gst_am_mediaformat_free (GstAmMediaFormat * self); + +gboolean gst_am_mediaformat_get_float (GstAmMediaFormat * self, + const gchar *key, gfloat *value); +gboolean gst_am_mediaformat_set_float (GstAmMediaFormat * self, + const gchar *key, gfloat value); +gboolean gst_am_mediaformat_get_int (GstAmMediaFormat * self, + const gchar *key, gint *value); +gboolean gst_am_mediaformat_set_int (GstAmMediaFormat * self, + const gchar *key, gint value); +gboolean gst_am_mediaformat_get_long (GstAmMediaFormat * self, + const gchar *key, glong *value); +gboolean gst_am_mediaformat_set_long (GstAmMediaFormat * self, + const gchar *key, glong value); +gboolean gst_am_mediaformat_get_string (GstAmMediaFormat * self, + const gchar *key, gchar **value); +gboolean gst_am_mediaformat_set_string (GstAmMediaFormat * self, + const gchar *key, const gchar *value); +gboolean gst_am_mediaformat_get_buffer (GstAmMediaFormat * self, + const gchar *key, GstBuffer **value); +gboolean gst_am_mediaformat_set_buffer (GstAmMediaFormat * self, + const gchar *key, GstBuffer *value); + + +gboolean gst_am_mediaformat_contains_key (GstAmMediaFormat * self, + const gchar *key); +gchar * gst_am_mediaformat_to_string (GstAmMediaFormat * self); + +G_END_DECLS + +#endif /* __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ */ From ea43e42ca55a7b5ac62e715c9168f58fdd909921 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Wed, 12 Dec 2012 18:10:13 +0000 Subject: [PATCH 67/82] androidmedia: Remove g_return_if_fails() This is not public API so it has no advantage to have them here. --- .../gst-android-media-mediacodec.c | 34 ------------- .../gst-android-media-mediaformat.c | 49 ------------------- 2 files changed, 83 deletions(-) diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c index 9e9bd2451b..6a214f7990 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -147,9 +147,6 @@ gst_am_mediacodec_configure (GstAmMediaCodec * self, GstAmMediaFormat * format, { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (format != NULL, FALSE); - AMMC_CALL (return FALSE, Void, configure, format->object, NULL, NULL, flags); return TRUE; @@ -163,8 +160,6 @@ gst_am_mediacodec_create_by_codec_name (const gchar * name) jobject object = NULL; jstring name_str; - g_return_val_if_fail (name != NULL, NULL); - name_str = (*env)->NewStringUTF (env, name); if (name_str == NULL) goto done; @@ -197,8 +192,6 @@ gst_am_mediacodec_get_output_format (GstAmMediaCodec * self) GstAmMediaFormat *format = NULL; jobject object = NULL; - g_return_val_if_fail (self != NULL, NULL); - object = AMMC_CALL (return NULL, Object, getOutputFormat); if (object) { format = g_slice_new0 (GstAmMediaFormat); @@ -220,8 +213,6 @@ gst_am_mediacodec_start (GstAmMediaCodec * self) { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - AMMC_CALL (return FALSE, Void, start); return TRUE; @@ -232,8 +223,6 @@ gst_am_mediacodec_stop (GstAmMediaCodec * self) { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - AMMC_CALL (return FALSE, Void, stop); return TRUE; @@ -244,8 +233,6 @@ gst_am_mediacodec_flush (GstAmMediaCodec * self) { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - AMMC_CALL (return FALSE, Void, flush); return TRUE; @@ -256,8 +243,6 @@ gst_am_mediacodec_release (GstAmMediaCodec * self) { JNIEnv *env = gst_dvm_get_env (); - g_return_if_fail (self != NULL); - AMMC_CALL (, Void, release); (*env)->DeleteGlobalRef (env, self->object); @@ -270,8 +255,6 @@ gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers) JNIEnv *env = gst_dvm_get_env (); jsize i; - g_return_if_fail (buffers != NULL); - for (i = 0; i < n_buffers; i++) { if (buffers[i].object) (*env)->DeleteGlobalRef (env, buffers[i].object); @@ -288,9 +271,6 @@ gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers) GstAmcBuffer *ret = NULL; jsize i; - g_return_val_if_fail (self != NULL, NULL); - g_return_val_if_fail (n_buffers != NULL, NULL); - *n_buffers = 0; output_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); if (!output_buffers) @@ -356,9 +336,6 @@ gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers) GstAmcBuffer *ret = NULL; jsize i; - g_return_val_if_fail (self != NULL, NULL); - g_return_val_if_fail (n_buffers != NULL, NULL); - *n_buffers = 0; input_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); @@ -423,8 +400,6 @@ gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, JNIEnv *env = gst_dvm_get_env (); gint ret = G_MININT; - g_return_val_if_fail (self != NULL, G_MININT); - ret = AMMC_CALL (return G_MININT, Int, dequeueInputBuffer, timeoutUs); return ret; @@ -433,8 +408,6 @@ gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, static gboolean _fill_buffer_info (JNIEnv * env, jobject buffer_info, GstAmmcBufferInfo * info) { - g_return_val_if_fail (buffer_info != NULL, FALSE); - info->flags = (*env)->GetIntField (env, buffer_info, android_media_mediacodec_bufferinfo.flags); if ((*env)->ExceptionCheck (env)) { @@ -478,8 +451,6 @@ gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, gint ret = G_MININT; jobject info_o = NULL; - g_return_val_if_fail (self != NULL, G_MININT); - info_o = (*env)->NewObject (env, android_media_mediacodec_bufferinfo.klass, android_media_mediacodec_bufferinfo.constructor); if (!info_o) { @@ -511,9 +482,6 @@ gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, gint index, { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (info != NULL, FALSE); - AMMC_CALL (return FALSE, Void, queueInputBuffer, index, info->offset, info->size, info->presentation_time_us, info->flags); @@ -525,8 +493,6 @@ gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, gint index) { JNIEnv *env = gst_dvm_get_env (); - g_return_val_if_fail (self != NULL, FALSE); - AMMC_CALL (return FALSE, Void, releaseOutputBuffer, index, JNI_FALSE); return TRUE; diff --git a/sys/androidmedia/gst-android-media-mediaformat.c b/sys/androidmedia/gst-android-media-mediaformat.c index e4e9eadb34..ee7baede7f 100644 --- a/sys/androidmedia/gst-android-media-mediaformat.c +++ b/sys/androidmedia/gst-android-media-mediaformat.c @@ -154,8 +154,6 @@ gst_am_mediaformat_create_audio_format (const gchar * mime, jstring mime_str; jobject object = NULL; - g_return_val_if_fail (mime != NULL, NULL); - mime_str = (*env)->NewStringUTF (env, mime); if (mime_str == NULL) goto done; @@ -190,8 +188,6 @@ gst_am_mediaformat_create_video_format (const gchar * mime, jstring mime_str; jobject object = NULL; - g_return_val_if_fail (mime != NULL, NULL); - mime_str = (*env)->NewStringUTF (env, mime); if (mime_str == NULL) goto done; @@ -222,8 +218,6 @@ gst_am_mediaformat_free (GstAmMediaFormat * self) { JNIEnv *env = gst_dvm_get_env (); - g_return_if_fail (self != NULL); - (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAmMediaFormat, self); } @@ -236,8 +230,6 @@ gst_am_mediaformat_to_string (GstAmMediaFormat * self) const gchar *v = NULL; gchar *ret = NULL; - g_return_val_if_fail (self != NULL, FALSE); - v_str = AMMF_CALL (return NULL, Object, toString); if (v_str) { v = (*env)->GetStringUTFChars (env, v_str, NULL); @@ -265,9 +257,6 @@ gst_am_mediaformat_contains_key (GstAmMediaFormat * self, const gchar * key) gboolean ret = FALSE; jstring key_str = NULL; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; @@ -289,10 +278,6 @@ gst_am_mediaformat_get_float (GstAmMediaFormat * self, const gchar * key, jstring key_str = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - *value = 0; key_str = (*env)->NewStringUTF (env, key); @@ -317,9 +302,6 @@ gst_am_mediaformat_set_float (GstAmMediaFormat * self, const gchar * key, jstring key_str = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; @@ -342,10 +324,6 @@ gst_am_mediaformat_get_int (GstAmMediaFormat * self, const gchar * key, jstring key_str = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - *value = 0; key_str = (*env)->NewStringUTF (env, key); @@ -371,9 +349,6 @@ gst_am_mediaformat_set_int (GstAmMediaFormat * self, const gchar * key, jstring key_str = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; @@ -397,10 +372,6 @@ gst_am_mediaformat_get_long (GstAmMediaFormat * self, const gchar * key, gboolean ret = FALSE; jlong long_value; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - *value = 0; key_str = (*env)->NewStringUTF (env, key); @@ -428,9 +399,6 @@ gst_am_mediaformat_set_long (GstAmMediaFormat * self, const gchar * key, gboolean ret = FALSE; jlong long_value = value; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; @@ -455,10 +423,6 @@ gst_am_mediaformat_get_string (GstAmMediaFormat * self, const gchar * key, jstring v_str = NULL; const gchar *v = NULL; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - *value = 0; key_str = (*env)->NewStringUTF (env, key); @@ -498,10 +462,6 @@ gst_am_mediaformat_set_string (GstAmMediaFormat * self, const gchar * key, jstring v_str = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; @@ -532,10 +492,6 @@ gst_am_mediaformat_get_buffer (GstAmMediaFormat * self, const gchar * key, guint8 *data; gsize size; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - *value = 0; key_str = (*env)->NewStringUTF (env, key); @@ -574,11 +530,6 @@ gst_am_mediaformat_set_buffer (GstAmMediaFormat * self, const gchar * key, jobject v = NULL; gboolean ret = FALSE; - g_return_val_if_fail (self != NULL, FALSE); - g_return_val_if_fail (key != NULL, FALSE); - g_return_val_if_fail (value != NULL, FALSE); - - key_str = (*env)->NewStringUTF (env, key); if (!key_str) goto done; From ff435e2a7d7572402ba8f78a51085e76bbe0dd14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 12:13:12 +0000 Subject: [PATCH 68/82] dvm: Add some more helper macros --- gst-libs/gst/dvm/gst-dvm.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/gst-libs/gst/dvm/gst-dvm.h b/gst-libs/gst/dvm/gst-dvm.h index e3f15fd087..5905d81897 100644 --- a/gst-libs/gst/dvm/gst-dvm.h +++ b/gst-libs/gst/dvm/gst-dvm.h @@ -71,6 +71,14 @@ return FALSE; \ } +#define GST_DVM_GET_STATIC_FIELD(k, field, signature) \ + k.field = (*env)->GetStaticFieldID (env, k.klass, #field, signature); \ + if (!k.field) { \ + (*env)->ExceptionClear (env); \ + GST_ERROR ("Failed to get static field %s for %s", #field, #k); \ + return FALSE; \ + } + #define GST_DVM_GET_FIELD(k, field, signature) \ k.field = (*env)->GetFieldID (env, k.klass, #field, signature); \ if (!k.field) { \ @@ -114,7 +122,23 @@ error_statement; \ } +#define GST_DVM_FIELD(error_statement, obj, type, k, field) \ + (*env)->Get##type##Field (env, obj, k.field); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to get Java field"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } +#define GST_DVM_STATIC_FIELD(error_statement, type, k, field) \ + (*env)->Get##type##Field (env, k.klass, k.field); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to get Java static field"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } JNIEnv *gst_dvm_get_env (void); gboolean gst_dvm_init (void); From ade85907780a317d856d6fd71e5c530bbd78403e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 12:13:27 +0000 Subject: [PATCH 69/82] androidmedia: Add remaining bits of the Java wrappers using libgstdvm --- .../gst-android-media-mediacodec.c | 84 +-- .../gst-android-media-mediacodec.h | 10 + .../gst-android-media-mediacodecinfo.c | 491 ++++++++++++++++++ .../gst-android-media-mediacodecinfo.h | 91 ++++ .../gst-android-media-mediacodeclist.c | 116 +++++ .../gst-android-media-mediacodeclist.h | 40 ++ .../gst-android-media-mediaformat.c | 1 + .../gst-android-media-mediaformat.h | 4 +- 8 files changed, 800 insertions(+), 37 deletions(-) create mode 100644 sys/androidmedia/gst-android-media-mediacodecinfo.c create mode 100644 sys/androidmedia/gst-android-media-mediacodecinfo.h create mode 100644 sys/androidmedia/gst-android-media-mediacodeclist.c create mode 100644 sys/androidmedia/gst-android-media-mediacodeclist.h diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c index 6a214f7990..306dfc51b9 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -56,10 +56,14 @@ static struct jmethodID releaseOutputBuffer; jmethodID start; jmethodID stop; -} android_media_mediacodec = { -0}; - - + jint BUFFER_FLAG_SYNC_FRAME; + jint BUFFER_FLAG_CODEC_CONFIG; + jint BUFFER_FLAG_END_OF_STREAM; + jint CONFIGURE_FLAG_ENCODE; + jint INFO_TRY_AGAIN_LATER; + jint INFO_OUTPUT_FORMAT_CHANGED; + jint INFO_OUTPUT_BUFFERS_CHANGED; +} android_media_mediacodec; static gboolean _init_classes (void) @@ -93,6 +97,38 @@ _init_classes (void) GST_DVM_GET_METHOD (android_media_mediacodec, start, "()V"); GST_DVM_GET_METHOD (android_media_mediacodec, stop, "()V"); + + GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_SYNC_FRAME, Int, + "I"); + MediaCodec_BUFFER_FLAG_SYNC_FRAME = + android_media_mediacodec.BUFFER_FLAG_SYNC_FRAME; + GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_CODEC_CONFIG, Int, + "I"); + MediaCodec_BUFFER_FLAG_CODEC_CONFIG = + android_media_mediacodec.BUFFER_FLAG_CODEC_CONFIG; + GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_END_OF_STREAM, + Int, "I"); + MediaCodec_BUFFER_FLAG_END_OF_STREAM = + android_media_mediacodec.BUFFER_FLAG_END_OF_STREAM; + + GST_DVM_GET_CONSTANT (android_media_mediacodec, CONFIGURE_FLAG_ENCODE, Int, + "I"); + MediaCodec_CONFIGURE_FLAG_ENCODE = + android_media_mediacodec.CONFIGURE_FLAG_ENCODE; + + GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_TRY_AGAIN_LATER, Int, + "I"); + MediaCodec_INFO_TRY_AGAIN_LATER = + android_media_mediacodec.INFO_TRY_AGAIN_LATER; + GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_OUTPUT_FORMAT_CHANGED, + Int, "I"); + MediaCodec_INFO_OUTPUT_FORMAT_CHANGED = + android_media_mediacodec.INFO_OUTPUT_FORMAT_CHANGED; + GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_OUTPUT_BUFFERS_CHANGED, + Int, "I"); + MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED = + android_media_mediacodec.INFO_OUTPUT_BUFFERS_CHANGED; + /* android.media.MediaCodec.BufferInfo */ GST_DVM_GET_CLASS (android_media_mediacodec_bufferinfo, "android/media/MediaCodec$BufferInfo"); @@ -405,40 +441,18 @@ gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, return ret; } +#define AMMCBI_FIELD(error_statement, type, field) \ + GST_DVM_FIELD (error_statement, buffer_info, type, \ + android_media_mediacodec_bufferinfo, field); + static gboolean _fill_buffer_info (JNIEnv * env, jobject buffer_info, GstAmmcBufferInfo * info) { - info->flags = (*env)->GetIntField (env, buffer_info, - android_media_mediacodec_bufferinfo.flags); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer info field"); - return FALSE; - } - - info->offset = (*env)->GetIntField (env, buffer_info, - android_media_mediacodec_bufferinfo.offset); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer info field"); - return FALSE; - } - - info->presentation_time_us = (*env)->GetLongField (env, buffer_info, - android_media_mediacodec_bufferinfo.presentationTimeUs); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer info field"); - return FALSE; - } - - info->size = (*env)->GetIntField (env, buffer_info, - android_media_mediacodec_bufferinfo.size); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer info field"); - return FALSE; - } + info->flags = AMMCBI_FIELD (return FALSE, Int, flags); + info->offset = AMMCBI_FIELD (return FALSE, Int, offset); + info->presentation_time_us = + AMMCBI_FIELD (return FALSE, Long, presentationTimeUs); + info->size = AMMCBI_FIELD (return FALSE, Int, size); return TRUE; } diff --git a/sys/androidmedia/gst-android-media-mediacodec.h b/sys/androidmedia/gst-android-media-mediacodec.h index 4e242615d7..4089ae52fc 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.h +++ b/sys/androidmedia/gst-android-media-mediacodec.h @@ -52,6 +52,16 @@ struct _GstAmMediaCodec { jobject object; /* global reference */ }; +extern gint MediaCodec_BUFFER_FLAG_SYNC_FRAME; +extern gint MediaCodec_BUFFER_FLAG_CODEC_CONFIG; +extern gint MediaCodec_BUFFER_FLAG_END_OF_STREAM; + +extern gint MediaCodec_CONFIGURE_FLAG_ENCODE; + +extern gint MediaCodec_INFO_TRY_AGAIN_LATER; +extern gint MediaCodec_INFO_OUTPUT_FORMAT_CHANGED; +extern gint MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED; + gboolean gst_android_media_mediacodec_init (void); void gst_android_media_mediacodec_deinit (void); diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.c b/sys/androidmedia/gst-android-media-mediacodecinfo.c new file mode 100644 index 0000000000..bd897a7373 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodecinfo.c @@ -0,0 +1,491 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gst-android-media-mediacodecinfo.h" + +static struct +{ + jclass klass; + jmethodID getCapabilitiesForType; + jmethodID getName; + jmethodID getSupportedTypes; + jmethodID isEncoder; +} android_media_mediacodecinfo; + +static struct +{ + jclass klass; + jfieldID colorFormats; + jfieldID profileLevels; +} android_media_mediacodeccapabilities; + +static struct +{ + jclass klass; + jfieldID level; + jfieldID profile; +} android_media_mediacodecprofilelevel; + +static struct +{ + jclass klass; + + jint CHANNEL_OUT_FRONT_LEFT; + jint CHANNEL_OUT_FRONT_RIGHT; + jint CHANNEL_OUT_FRONT_CENTER; + jint CHANNEL_OUT_LOW_FREQUENCY; + jint CHANNEL_OUT_BACK_LEFT; + jint CHANNEL_OUT_BACK_RIGHT; + jint CHANNEL_OUT_FRONT_LEFT_OF_CENTER; + jint CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; + jint CHANNEL_OUT_BACK_CENTER; + jint CHANNEL_OUT_SIDE_LEFT; + jint CHANNEL_OUT_SIDE_RIGHT; + jint CHANNEL_OUT_TOP_CENTER; + jint CHANNEL_OUT_TOP_FRONT_LEFT; + jint CHANNEL_OUT_TOP_FRONT_CENTER; + jint CHANNEL_OUT_TOP_FRONT_RIGHT; + jint CHANNEL_OUT_TOP_BACK_LEFT; + jint CHANNEL_OUT_TOP_BACK_CENTER; + jint CHANNEL_OUT_TOP_BACK_RIGHT; +} android_media_audioformat; + +static gboolean +_init_classes (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.media.MediaCodecInfo */ + GST_DVM_GET_CLASS (android_media_mediacodecinfo, + "android/media/MediaCodecInfo"); + GST_DVM_GET_METHOD (android_media_mediacodecinfo, getCapabilitiesForType, + "(Ljava/lang/String;)Landroid/media/MediaCodecInfo$CodecCapabilities;"); + GST_DVM_GET_METHOD (android_media_mediacodecinfo, getName, + "()Ljava/lang/String;"); + GST_DVM_GET_METHOD (android_media_mediacodecinfo, getSupportedTypes, + "()[java/lang/String;"); + GST_DVM_GET_METHOD (android_media_mediacodecinfo, isEncoder, "()Z"); + + GST_DVM_GET_CLASS (android_media_mediacodeccapabilities, + "android/media/MediaCodecInfo$CodecCapabilities"); + GST_DVM_GET_FIELD (android_media_mediacodeccapabilities, colorFormats, "[I"); + GST_DVM_GET_FIELD (android_media_mediacodeccapabilities, profileLevels, + "[Landroid/media/MediaCodecInfo$CodecProfileLevel;"); + + GST_DVM_GET_CLASS (android_media_mediacodecprofilelevel, + "android/media/MediaCodecInfo$ProfileLevel"); + GST_DVM_GET_FIELD (android_media_mediacodecprofilelevel, level, "I"); + GST_DVM_GET_FIELD (android_media_mediacodecprofilelevel, profile, "I"); + + GST_DVM_GET_CLASS (android_media_audioformat, "android/media/AudioFormat"); + + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_LEFT, Int, + "I"); + AudioFormat_CHANNEL_OUT_FRONT_LEFT = + android_media_audioformat.CHANNEL_OUT_FRONT_LEFT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_RIGHT, Int, + "I"); + AudioFormat_CHANNEL_OUT_FRONT_RIGHT = + android_media_audioformat.CHANNEL_OUT_FRONT_RIGHT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_CENTER, + Int, "I"); + AudioFormat_CHANNEL_OUT_FRONT_CENTER = + android_media_audioformat.CHANNEL_OUT_FRONT_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_LOW_FREQUENCY, + Int, "I"); + AudioFormat_CHANNEL_OUT_LOW_FREQUENCY = + android_media_audioformat.CHANNEL_OUT_LOW_FREQUENCY; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_LEFT, Int, + "I"); + AudioFormat_CHANNEL_OUT_BACK_LEFT = + android_media_audioformat.CHANNEL_OUT_BACK_LEFT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_RIGHT, Int, + "I"); + AudioFormat_CHANNEL_OUT_BACK_RIGHT = + android_media_audioformat.CHANNEL_OUT_BACK_RIGHT; + GST_DVM_GET_CONSTANT (android_media_audioformat, + CHANNEL_OUT_FRONT_LEFT_OF_CENTER, Int, "I"); + AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = + android_media_audioformat.CHANNEL_OUT_FRONT_LEFT_OF_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, + CHANNEL_OUT_FRONT_RIGHT_OF_CENTER, Int, "I"); + AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = + android_media_audioformat.CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_CENTER, Int, + "I"); + AudioFormat_CHANNEL_OUT_BACK_CENTER = + android_media_audioformat.CHANNEL_OUT_BACK_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_SIDE_LEFT, Int, + "I"); + AudioFormat_CHANNEL_OUT_SIDE_LEFT = + android_media_audioformat.CHANNEL_OUT_SIDE_LEFT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_SIDE_RIGHT, Int, + "I"); + AudioFormat_CHANNEL_OUT_SIDE_RIGHT = + android_media_audioformat.CHANNEL_OUT_SIDE_RIGHT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_CENTER, Int, + "I"); + AudioFormat_CHANNEL_OUT_TOP_CENTER = + android_media_audioformat.CHANNEL_OUT_TOP_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_LEFT, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT = + android_media_audioformat.CHANNEL_OUT_TOP_FRONT_LEFT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_CENTER, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER = + android_media_audioformat.CHANNEL_OUT_TOP_FRONT_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_RIGHT, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT = + android_media_audioformat.CHANNEL_OUT_TOP_FRONT_RIGHT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_LEFT, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT = + android_media_audioformat.CHANNEL_OUT_TOP_BACK_LEFT; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_CENTER, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER = + android_media_audioformat.CHANNEL_OUT_TOP_BACK_CENTER; + GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_RIGHT, + Int, "I"); + AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT = + android_media_audioformat.CHANNEL_OUT_TOP_BACK_RIGHT; + + return TRUE; +} + +gboolean +gst_android_media_mediacodecinfo_init (void) +{ + if (!_init_classes ()) { + gst_android_media_mediacodecinfo_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_media_mediacodecinfo_deinit (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_media_mediacodecinfo.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodecinfo.klass); + android_media_mediacodecinfo.klass = NULL; + + if (android_media_mediacodeccapabilities.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodeccapabilities.klass); + android_media_mediacodeccapabilities.klass = NULL; + + if (android_media_mediacodecprofilelevel.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodecprofilelevel.klass); + android_media_mediacodecprofilelevel.klass = NULL; + + if (android_media_audioformat.klass) + (*env)->DeleteGlobalRef (env, android_media_audioformat.klass); + android_media_audioformat.klass = NULL; +} + +/* android.media.MediaCodecInfo */ +#define AMMCI_CALL(error_statement, type, method, ...) \ + GST_DVM_CALL (error_statement, self->object, type, \ + android_media_mediacodecinfo, method, ## __VA_ARGS__); + +void +gst_am_mediacodecinfo_free (GstAmMediaCodecInfo * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAmMediaCodecInfo, self); +} + +void +gst_am_mediacodeccapabilities_free (GstAmMediaCodecCapabilities * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAmMediaCodecCapabilities, self); +} + +void +gst_am_mediacodecprofilelevel_free (GstAmMediaCodecProfileLevel * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + (*env)->DeleteGlobalRef (env, self->object); + g_slice_free (GstAmMediaCodecProfileLevel, self); +} + + +GstAmMediaCodecCapabilities * +gst_am_mediacodecinfo_get_capabilities_for_type (GstAmMediaCodecInfo * self, + const gchar * type) +{ + JNIEnv *env = gst_dvm_get_env (); + jobject object = NULL; + jstring type_str = NULL; + GstAmMediaCodecCapabilities *caps = NULL; + + type_str = (*env)->NewStringUTF (env, type); + if (!type_str) + goto done; + + object = AMMCI_CALL (goto done, Object, getCapabilitiesForType, type_str); + + if (object) { + caps = g_slice_new0 (GstAmMediaCodecCapabilities); + caps->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!caps->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaCodecCapabilities, caps); + caps = NULL; + } + } + +done: + if (type_str) + (*env)->DeleteLocalRef (env, type_str); + + return caps; +} + +gchar * +gst_am_mediacodecinfo_get_name (GstAmMediaCodecInfo * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jstring v_str = NULL; + const gchar *v = NULL; + gchar *ret = NULL; + + v_str = AMMCI_CALL (return NULL, Object, getName); + if (v_str) { + v = (*env)->GetStringUTFChars (env, v_str, NULL); + if (!v) { + GST_ERROR ("Failed to convert string to UTF8"); + (*env)->ExceptionClear (env); + goto done; + } + ret = g_strdup (v); + } + +done: + if (v) + (*env)->ReleaseStringUTFChars (env, v_str, v); + if (v_str) + (*env)->DeleteLocalRef (env, v_str); + + return ret; +} + +GList * +gst_am_mediacodecinfo_get_supported_types (GstAmMediaCodecInfo * self) +{ + JNIEnv *env = gst_dvm_get_env (); + jarray arr = NULL; + jint arr_len = 0; + GList *ret = NULL; + gint i; + + arr = AMMCI_CALL (goto done, Object, getSupportedTypes); + if (!arr) + goto done; + arr_len = (*env)->GetArrayLength (env, arr); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array length"); + goto done; + } + + for (i = 0; i < arr_len; i++) { + jstring str = NULL; + const gchar *str_v = NULL; + + str = (*env)->GetObjectArrayElement (env, arr, i); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array element %d", i); + continue; + } + if (!str) + continue; + + str_v = (*env)->GetStringUTFChars (env, str, NULL); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get string characters"); + (*env)->DeleteLocalRef (env, str); + str = NULL; + continue; + } + ret = g_list_append (ret, g_strdup (str_v)); + (*env)->ReleaseStringUTFChars (env, str, str_v); + str_v = NULL; + (*env)->DeleteLocalRef (env, str); + str = NULL; + } + +done: + if (arr) + (*env)->DeleteLocalRef (env, arr); + + return ret; +} + +gboolean +gst_am_mediacodecinfo_is_encoder (GstAmMediaCodecInfo * self) +{ + JNIEnv *env = gst_dvm_get_env (); + gboolean ret = FALSE; + + ret = AMMCI_CALL (return FALSE, Boolean, isEncoder); + + return ret; +} + +#define AMMCC_FIELD(error_statement, type, field) \ + GST_DVM_FIELD (error_statement, self->object, type, \ + android_media_mediacodeccapabilities, field); + +GList * +gst_am_mediacodeccapabilities_get_color_formats (GstAmMediaCodecCapabilities * + self) +{ + JNIEnv *env = gst_dvm_get_env (); + GList *ret = NULL; + jarray arr = NULL; + jint arr_len = 0; + jint *arr_n = NULL; + gint i; + + arr = AMMCC_FIELD (goto done, Object, colorFormats); + arr_len = (*env)->GetArrayLength (env, arr); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array length"); + goto done; + } + + arr_n = (*env)->GetIntArrayElements (env, arr, NULL); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array elements"); + goto done; + } + + for (i = 0; i < arr_len; i++) + ret = g_list_append (ret, GINT_TO_POINTER (arr_n[i])); + +done: + if (arr_n) + (*env)->ReleaseIntArrayElements (env, arr, arr_n, JNI_ABORT); + if (arr) + (*env)->DeleteLocalRef (env, arr); + + return ret; +} + +GList * +gst_am_mediacodeccapabilities_get_profile_levels (GstAmMediaCodecCapabilities * + self) +{ + JNIEnv *env = gst_dvm_get_env (); + jarray arr = NULL; + jint arr_len = 0; + GList *ret = NULL; + gint i; + + arr = AMMCC_FIELD (goto done, Object, profileLevels); + if (!arr) + goto done; + arr_len = (*env)->GetArrayLength (env, arr); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array length"); + goto done; + } + + for (i = 0; i < arr_len; i++) { + jobject object = NULL; + + object = (*env)->GetObjectArrayElement (env, arr, i); + if ((*env)->ExceptionCheck (env)) { + (*env)->ExceptionClear (env); + GST_ERROR ("Failed to get array element %d", i); + continue; + } + if (!object) + continue; + + if (object) { + GstAmMediaCodecProfileLevel *profile_level = + g_slice_new0 (GstAmMediaCodecProfileLevel); + + profile_level->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + object = NULL; + if (!profile_level->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaCodecProfileLevel, profile_level); + } else { + ret = g_list_append (ret, profile_level); + } + } + } + +done: + if (arr) + (*env)->DeleteLocalRef (env, arr); + + return ret; +} + +#define AMMCPL_FIELD(error_statement, type, field) \ + GST_DVM_FIELD (error_statement, self->object, type, \ + android_media_mediacodecprofilelevel, field); + +gint +gst_am_mediacodecprofilelevel_get_level (GstAmMediaCodecProfileLevel * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + return AMMCPL_FIELD (return -1, Int, level); +} + +gint +gst_am_mediacodecprofilelevel_get_profile (GstAmMediaCodecProfileLevel * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + return AMMCPL_FIELD (return -1, Int, profile); +} diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.h b/sys/androidmedia/gst-android-media-mediacodecinfo.h new file mode 100644 index 0000000000..bcdb91f770 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodecinfo.h @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ +#define __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ + +#include +#include + +G_BEGIN_DECLS + +typedef struct _GstAmMediaCodecInfo GstAmMediaCodecInfo; +typedef struct _GstAmMediaCodecCapabilities GstAmMediaCodecCapabilities; +typedef struct _GstAmMediaCodecProfileLevel GstAmMediaCodecProfileLevel; + +struct _GstAmMediaCodecInfo { + /*< private >*/ + jobject object; /* global reference */ +}; + +struct _GstAmMediaCodecCapabilities { + /*< private >*/ + jobject object; /* global reference */ +}; + +struct _GstAmMediaCodecProfileLevel { + /*< private >*/ + jobject object; /* global reference */ +}; + +gboolean gst_android_media_mediacodecinfo_init (void); +void gst_android_media_mediacodecinfo_deinit (void); + +void gst_am_mediacodecinfo_free (GstAmMediaCodecInfo * self); +void gst_am_mediacodeccapabilities_free (GstAmMediaCodecCapabilities * self); +void gst_am_mediacodecprofilelevel_free (GstAmMediaCodecProfileLevel * self); + +GstAmMediaCodecCapabilities * gst_am_mediacodecinfo_get_capabilities_for_type (GstAmMediaCodecInfo * self, const gchar *type); +gchar * gst_am_mediacodecinfo_get_name (GstAmMediaCodecInfo * self); +/* GList */ +GList * gst_am_mediacodecinfo_get_supported_types (GstAmMediaCodecInfo * self); +gboolean gst_am_mediacodecinfo_is_encoder (GstAmMediaCodecInfo * self); + +/* GList */ +GList * gst_am_mediacodeccapabilities_get_color_formats (GstAmMediaCodecCapabilities *self); +/* GList */ +GList * gst_am_mediacodeccapabilities_get_profile_levels (GstAmMediaCodecCapabilities *self); + +gint gst_am_mediacodecprofilelevel_get_level (GstAmMediaCodecProfileLevel *self); +gint gst_am_mediacodecprofilelevel_get_profile (GstAmMediaCodecProfileLevel *self); + +extern gint AudioFormat_CHANNEL_OUT_FRONT_LEFT; +extern gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT; +extern gint AudioFormat_CHANNEL_OUT_FRONT_CENTER; +extern gint AudioFormat_CHANNEL_OUT_LOW_FREQUENCY; +extern gint AudioFormat_CHANNEL_OUT_BACK_LEFT; +extern gint AudioFormat_CHANNEL_OUT_BACK_RIGHT; +extern gint AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER; +extern gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; +extern gint AudioFormat_CHANNEL_OUT_BACK_CENTER; +extern gint AudioFormat_CHANNEL_OUT_SIDE_LEFT; +extern gint AudioFormat_CHANNEL_OUT_SIDE_RIGHT; +extern gint AudioFormat_CHANNEL_OUT_TOP_CENTER; +extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT; +extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER; +extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT; +extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT; +extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER; +extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT; + +G_END_DECLS + +#endif /* __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediacodeclist.c b/sys/androidmedia/gst-android-media-mediacodeclist.c new file mode 100644 index 0000000000..faa5a8f89a --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodeclist.c @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gst-android-media-mediacodeclist.h" + +static struct +{ + jclass klass; + jmethodID getCodecCount; + jmethodID getCodecInfoAt; +} android_media_mediacodeclist; + + +static gboolean +_init_classes (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + /* android.media.MediaCodecList */ + GST_DVM_GET_CLASS (android_media_mediacodeclist, + "android/media/MediaCodecList"); + GST_DVM_GET_STATIC_METHOD (android_media_mediacodeclist, getCodecCount, + "()I;"); + GST_DVM_GET_STATIC_METHOD (android_media_mediacodeclist, getCodecInfoAt, + "(I)Landroid/media/MediaCodecInfo;"); + + return TRUE; +} + +gboolean +gst_android_media_mediacodeclist_init (void) +{ + if (!_init_classes ()) { + gst_android_media_mediacodeclist_deinit (); + return FALSE; + } + + return TRUE; +} + +void +gst_android_media_mediacodeclist_deinit (void) +{ + JNIEnv *env = gst_dvm_get_env (); + + if (android_media_mediacodeclist.klass) + (*env)->DeleteGlobalRef (env, android_media_mediacodeclist.klass); + android_media_mediacodeclist.klass = NULL; +} + +/* android.media.MediaFormat */ +#define AMMCL_STATIC_CALL(error_statement, type, method, ...) \ + GST_DVM_STATIC_CALL (error_statement, type, \ + android_media_mediacodeclist, method, ## __VA_ARGS__); + +gint +gst_am_mediacodeclist_get_codec_count (void) +{ + JNIEnv *env = gst_dvm_get_env (); + gint count = 0; + + count = AMMCL_STATIC_CALL (goto done, Int, getCodecCount); + +done: + + return count; +} + +GstAmMediaCodecInfo * +gst_am_mediacodeclist_get_codec_info_at (gint index) +{ + JNIEnv *env = gst_dvm_get_env (); + GstAmMediaCodecInfo *info = NULL; + jobject object = NULL; + + object = AMMCL_STATIC_CALL (goto done, Object, getCodecInfoAt, index); + if (object) { + info = g_slice_new0 (GstAmMediaCodecInfo); + info->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!info->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAmMediaCodecInfo, info); + info = NULL; + } + } + +done: + + return info; +} diff --git a/sys/androidmedia/gst-android-media-mediacodeclist.h b/sys/androidmedia/gst-android-media-mediacodeclist.h new file mode 100644 index 0000000000..e0241022e4 --- /dev/null +++ b/sys/androidmedia/gst-android-media-mediacodeclist.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Sebastian Dröge + * Author: Youness Alaoui + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ +#define __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ + +#include +#include + +#include "gst-android-media-mediacodecinfo.h" + +G_BEGIN_DECLS + +gboolean gst_android_media_mediacodeclist_init (void); +void gst_android_media_mediacodeclist_deinit (void); + +gint gst_am_mediacodeclist_get_codec_count (void); +GstAmMediaCodecInfo * gst_am_mediacodeclist_get_codec_info_at (int index); + +G_END_DECLS + +#endif /* __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediaformat.c b/sys/androidmedia/gst-android-media-mediaformat.c index ee7baede7f..e0ed338399 100644 --- a/sys/androidmedia/gst-android-media-mediaformat.c +++ b/sys/androidmedia/gst-android-media-mediaformat.c @@ -24,6 +24,7 @@ #endif #include +#include #include "gst-android-media-mediaformat.h" diff --git a/sys/androidmedia/gst-android-media-mediaformat.h b/sys/androidmedia/gst-android-media-mediaformat.h index 28158fccb1..a909d12737 100644 --- a/sys/androidmedia/gst-android-media-mediaformat.h +++ b/sys/androidmedia/gst-android-media-mediaformat.h @@ -25,6 +25,8 @@ #include #include +G_BEGIN_DECLS + typedef struct _GstAmMediaFormat GstAmMediaFormat; struct _GstAmMediaFormat { @@ -32,8 +34,6 @@ struct _GstAmMediaFormat { jobject object; /* global reference */ }; -G_BEGIN_DECLS - gboolean gst_android_media_mediaformat_init (void); void gst_android_media_mediaformat_deinit (void); From e3801c041fcd32d98fe786d96f8cede2683ac3a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 17:40:04 +0000 Subject: [PATCH 70/82] androidmedia: Make everything compile with the new wrappers --- .../gst-android-media-mediacodec.c | 34 ++++++++++++------- .../gst-android-media-mediacodec.h | 20 ++++++----- 2 files changed, 32 insertions(+), 22 deletions(-) diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c index 306dfc51b9..5cdbbd3a61 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -275,18 +275,25 @@ gst_am_mediacodec_flush (GstAmMediaCodec * self) } void -gst_am_mediacodec_release (GstAmMediaCodec * self) +gst_am_mediacodec_free (GstAmMediaCodec * self) { JNIEnv *env = gst_dvm_get_env (); - AMMC_CALL (, Void, release); - (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAmMediaCodec, self); } void -gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers) +gst_am_mediacodec_release (GstAmMediaCodec * self) +{ + JNIEnv *env = gst_dvm_get_env (); + + AMMC_CALL (, Void, release); +} + +void +gst_am_mediacodec_free_buffers (GstAmMediaCodecBuffer * buffers, + gsize n_buffers) { JNIEnv *env = gst_dvm_get_env (); jsize i; @@ -298,13 +305,13 @@ gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers) g_free (buffers); } -GstAmcBuffer * +GstAmMediaCodecBuffer * gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers) { JNIEnv *env = gst_dvm_get_env (); jobject output_buffers = NULL; jsize n_output_buffers; - GstAmcBuffer *ret = NULL; + GstAmMediaCodecBuffer *ret = NULL; jsize i; *n_buffers = 0; @@ -320,7 +327,7 @@ gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers) } *n_buffers = n_output_buffers; - ret = g_new0 (GstAmcBuffer, n_output_buffers); + ret = g_new0 (GstAmMediaCodecBuffer, n_output_buffers); for (i = 0; i < n_output_buffers; i++) { jobject buffer = NULL; @@ -363,13 +370,13 @@ error: goto done; } -GstAmcBuffer * +GstAmMediaCodecBuffer * gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers) { JNIEnv *env = gst_dvm_get_env (); jobject input_buffers = NULL; jsize n_input_buffers; - GstAmcBuffer *ret = NULL; + GstAmMediaCodecBuffer *ret = NULL; jsize i; *n_buffers = 0; @@ -386,7 +393,7 @@ gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers) } *n_buffers = n_input_buffers; - ret = g_new0 (GstAmcBuffer, n_input_buffers); + ret = g_new0 (GstAmMediaCodecBuffer, n_input_buffers); for (i = 0; i < n_input_buffers; i++) { jobject buffer = NULL; @@ -446,7 +453,8 @@ gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, android_media_mediacodec_bufferinfo, field); static gboolean -_fill_buffer_info (JNIEnv * env, jobject buffer_info, GstAmmcBufferInfo * info) +_fill_buffer_info (JNIEnv * env, jobject buffer_info, + GstAmMediaCodecBufferInfo * info) { info->flags = AMMCBI_FIELD (return FALSE, Int, flags); info->offset = AMMCBI_FIELD (return FALSE, Int, offset); @@ -459,7 +467,7 @@ _fill_buffer_info (JNIEnv * env, jobject buffer_info, GstAmmcBufferInfo * info) gint gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, - GstAmmcBufferInfo * info, gint64 timeoutUs) + GstAmMediaCodecBufferInfo * info, gint64 timeoutUs) { JNIEnv *env = gst_dvm_get_env (); gint ret = G_MININT; @@ -492,7 +500,7 @@ error: gboolean gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, gint index, - const GstAmmcBufferInfo * info) + const GstAmMediaCodecBufferInfo * info) { JNIEnv *env = gst_dvm_get_env (); diff --git a/sys/androidmedia/gst-android-media-mediacodec.h b/sys/androidmedia/gst-android-media-mediacodec.h index 4089ae52fc..2745eea293 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.h +++ b/sys/androidmedia/gst-android-media-mediacodec.h @@ -29,18 +29,18 @@ G_BEGIN_DECLS -typedef struct _GstAmcBuffer GstAmcBuffer; -typedef struct _GstAmmcBufferInfo GstAmmcBufferInfo; +typedef struct _GstAmMediaCodecBuffer GstAmMediaCodecBuffer; +typedef struct _GstAmMediaCodecBufferInfo GstAmMediaCodecBufferInfo; typedef struct _GstAmMediaCodec GstAmMediaCodec; -struct _GstAmcBuffer { +struct _GstAmMediaCodecBuffer { guint8 *data; gsize size; /*< private >*/ jobject object; /* global reference */ }; -struct _GstAmmcBufferInfo { +struct _GstAmMediaCodecBufferInfo { gint flags; gint offset; gint64 presentation_time_us; @@ -72,21 +72,23 @@ GstAmMediaCodec * gst_am_mediacodec_create_by_codec_name (const gchar *name); GstAmMediaCodec * gst_am_mediacodec_create_decoder_by_type (const gchar *type); GstAmMediaCodec * gst_am_mediacodec_create_encoder_by_type (const gchar *type); +void gst_am_mediacodec_free (GstAmMediaCodec * self); + gint gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, gint64 timeoutUs); gint gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, - GstAmmcBufferInfo *info, gint64 timeoutUs); + GstAmMediaCodecBufferInfo *info, gint64 timeoutUs); gboolean gst_am_mediacodec_flush (GstAmMediaCodec * self); -GstAmcBuffer * gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, +GstAmMediaCodecBuffer * gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers); -GstAmcBuffer * gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, +GstAmMediaCodecBuffer * gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers); -void gst_am_mediacodec_free_buffers (GstAmcBuffer * buffers, gsize n_buffers); +void gst_am_mediacodec_free_buffers (GstAmMediaCodecBuffer * buffers, gsize n_buffers); GstAmMediaFormat * gst_am_mediacodec_get_output_format (GstAmMediaCodec * self); gboolean gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, - gint index, const GstAmmcBufferInfo *info); + gint index, const GstAmMediaCodecBufferInfo *info); void gst_am_mediacodec_release (GstAmMediaCodec * self); gboolean gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, gint index); From 7da19b9bda3bfd5328073492c343fa650b004455 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 17:40:22 +0000 Subject: [PATCH 71/82] dvm: Add new function to check if we started a VM or only used an existing one --- gst-libs/gst/dvm/gst-dvm.c | 6 ++++++ gst-libs/gst/dvm/gst-dvm.h | 1 + 2 files changed, 7 insertions(+) diff --git a/gst-libs/gst/dvm/gst-dvm.c b/gst-libs/gst/dvm/gst-dvm.c index df2209ba52..8f84b0caad 100644 --- a/gst-libs/gst/dvm/gst-dvm.c +++ b/gst-libs/gst/dvm/gst-dvm.c @@ -157,3 +157,9 @@ create_failed: return FALSE; } } + +gboolean +gst_dvm_is_own_vm (void) +{ + return started_java_vm; +} diff --git a/gst-libs/gst/dvm/gst-dvm.h b/gst-libs/gst/dvm/gst-dvm.h index 5905d81897..b91e7fc627 100644 --- a/gst-libs/gst/dvm/gst-dvm.h +++ b/gst-libs/gst/dvm/gst-dvm.h @@ -142,5 +142,6 @@ JNIEnv *gst_dvm_get_env (void); gboolean gst_dvm_init (void); +gboolean gst_dvm_is_own_vm (void); #endif /* __GST_DVM_H__ */ From 64b869ea401d9520a9f60aa8549caeb10eae1a7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 17:56:01 +0000 Subject: [PATCH 72/82] dvm: Rename gst-dvm.[ch] to gstdvm.[ch] for consistency with other GStreamer code --- gst-libs/gst/dvm/Makefile.am | 4 ++-- gst-libs/gst/dvm/{gst-dvm.c => gstdvm.c} | 2 +- gst-libs/gst/dvm/{gst-dvm.h => gstdvm.h} | 0 sys/androidcamera/Makefile.am | 4 +++- sys/androidcamera/gst-android-graphics-imageformat.c | 2 +- sys/androidcamera/gst-android-graphics-surfacetexture.c | 2 +- sys/androidcamera/gst-android-hardware-camera.c | 2 +- sys/androidcamera/gst-androidcamera.c | 2 +- sys/androidcamera/gstahcsrc.c | 2 +- sys/androidmedia/gst-android-media-mediacodec.c | 2 +- sys/androidmedia/gst-android-media-mediacodecinfo.c | 2 +- sys/androidmedia/gst-android-media-mediacodeclist.c | 2 +- sys/androidmedia/gst-android-media-mediaformat.c | 2 +- 13 files changed, 15 insertions(+), 13 deletions(-) rename gst-libs/gst/dvm/{gst-dvm.c => gstdvm.c} (99%) rename gst-libs/gst/dvm/{gst-dvm.h => gstdvm.h} (100%) diff --git a/gst-libs/gst/dvm/Makefile.am b/gst-libs/gst/dvm/Makefile.am index d2f4d2abad..3da6f8616c 100644 --- a/gst-libs/gst/dvm/Makefile.am +++ b/gst-libs/gst/dvm/Makefile.am @@ -2,10 +2,10 @@ lib_LTLIBRARIES = libgstdvm-@GST_MAJORMINOR@.la libgstdvmincludedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/dvm libgstdvminclude_HEADERS = \ - gst-dvm.h + gstdvm.h libgstdvm_@GST_MAJORMINOR@_la_SOURCES = \ - gst-dvm.c + gstdvm.c libgstdvm_@GST_MAJORMINOR@_la_CFLAGS = \ $(GST_PLUGINS_BAD_CFLAGS) \ diff --git a/gst-libs/gst/dvm/gst-dvm.c b/gst-libs/gst/dvm/gstdvm.c similarity index 99% rename from gst-libs/gst/dvm/gst-dvm.c rename to gst-libs/gst/dvm/gstdvm.c index 8f84b0caad..82dea7b750 100644 --- a/gst-libs/gst/dvm/gst-dvm.c +++ b/gst-libs/gst/dvm/gstdvm.c @@ -24,7 +24,7 @@ #include "config.h" #endif -#include "gst-dvm.h" +#include "gstdvm.h" #include diff --git a/gst-libs/gst/dvm/gst-dvm.h b/gst-libs/gst/dvm/gstdvm.h similarity index 100% rename from gst-libs/gst/dvm/gst-dvm.h rename to gst-libs/gst/dvm/gstdvm.h diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am index f2a6ac5e2b..e24e94404f 100644 --- a/sys/androidcamera/Makefile.am +++ b/sys/androidcamera/Makefile.am @@ -18,6 +18,7 @@ noinst_HEADERS = \ gst-android-graphics-imageformat.h libgstandroidcamera_la_CFLAGS = \ + $(GST_PLUGINS_BAD_CFLAGS) \ $(GST_PLUGINS_BASE_CFLAGS) \ $(GST_BASE_CFLAGS) \ $(GST_CFLAGS) \ @@ -25,7 +26,8 @@ libgstandroidcamera_la_CFLAGS = \ libgstandroidcamera_la_LIBADD = \ $(GST_PLUGINS_BASE_LIBS) \ $(GST_BASE_LIBS) \ - $(GST_LIBS) + $(GST_LIBS) \ + $(top_builddir)/gst-libs/gst/dvm/libgstdvm-@GST_MAJORMINOR@.la libgstandroidcamera_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) libgstandroidcamera_la_LIBTOOLFLAGS = --tag=disable-static diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidcamera/gst-android-graphics-imageformat.c index 3140af048e..577131f27b 100644 --- a/sys/androidcamera/gst-android-graphics-imageformat.c +++ b/sys/androidcamera/gst-android-graphics-imageformat.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gst-android-graphics-imageformat.h" diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index bb78f0273c..06a29453fa 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gst-android-graphics-surfacetexture.h" diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 945c6e6cf4..09940b662d 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gstahccallback.h" #include "gst-android-hardware-camera.h" diff --git a/sys/androidcamera/gst-androidcamera.c b/sys/androidcamera/gst-androidcamera.c index 6aa2d412c0..d836add3ed 100644 --- a/sys/androidcamera/gst-androidcamera.c +++ b/sys/androidcamera/gst-androidcamera.c @@ -23,7 +23,7 @@ #endif #include -#include +#include #include "gst-android-hardware-camera.h" #include "gstahcsrc.h" diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 6f8f056e92..7ed1f22973 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -73,7 +73,7 @@ #include #include #include -#include +#include #include "gstahcsrc.h" diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c index 5cdbbd3a61..f87669c30d 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gst-android-media-mediacodec.h" diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.c b/sys/androidmedia/gst-android-media-mediacodecinfo.c index bd897a7373..86df3e0f98 100644 --- a/sys/androidmedia/gst-android-media-mediacodecinfo.c +++ b/sys/androidmedia/gst-android-media-mediacodecinfo.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gst-android-media-mediacodecinfo.h" diff --git a/sys/androidmedia/gst-android-media-mediacodeclist.c b/sys/androidmedia/gst-android-media-mediacodeclist.c index faa5a8f89a..dddcf13dd1 100644 --- a/sys/androidmedia/gst-android-media-mediacodeclist.c +++ b/sys/androidmedia/gst-android-media-mediacodeclist.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include "gst-android-media-mediacodeclist.h" diff --git a/sys/androidmedia/gst-android-media-mediaformat.c b/sys/androidmedia/gst-android-media-mediaformat.c index e0ed338399..ee1529b6cb 100644 --- a/sys/androidmedia/gst-android-media-mediaformat.c +++ b/sys/androidmedia/gst-android-media-mediaformat.c @@ -23,7 +23,7 @@ #include "config.h" #endif -#include +#include #include #include "gst-android-media-mediaformat.h" From acfb1c44a7b77013bc58d07886d4b1122389f503 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Thu, 13 Dec 2012 17:57:58 +0000 Subject: [PATCH 73/82] androidcamera: Fix some compiler warnings --- sys/androidcamera/gst-android-hardware-camera.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index 09940b662d..fada85e6f9 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -294,11 +294,14 @@ gst_ah_camera_on_auto_focus (JNIEnv * env, jclass klass, jboolean success, } static JNINativeMethod native_methods[] = { - {"gst_ah_camera_on_preview_frame", "([BLandroid/hardware/Camera;JJ)V", + {(gchar *) "gst_ah_camera_on_preview_frame", + (gchar *) "([BLandroid/hardware/Camera;JJ)V", (void *) gst_ah_camera_on_preview_frame}, - {"gst_ah_camera_on_error", "(ILandroid/hardware/Camera;JJ)V", + {(gchar *) "gst_ah_camera_on_error", + (gchar *) "(ILandroid/hardware/Camera;JJ)V", (void *) gst_ah_camera_on_error}, - {"gst_ah_camera_on_auto_focus", "(ZLandroid/hardware/Camera;JJ)V", + {(gchar *) "gst_ah_camera_on_auto_focus", + (gchar *) "(ZLandroid/hardware/Camera;JJ)V", (void *) gst_ah_camera_on_auto_focus} }; @@ -2898,7 +2901,7 @@ gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) jintArray range = java_util_iterator_next (env, iterator); if (range) { - jint *fps = malloc (sizeof (jint) * 2); + jint *fps = g_new (jint, 2); (*env)->GetIntArrayRegion (env, range, 0, 2, fps); ret = g_list_append (ret, fps); From 11b28224b52352acae9301065f220a220f438af8 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Thu, 29 Nov 2012 20:10:19 -0500 Subject: [PATCH 74/82] androidcamera: Small refactor in case open doesn't throw an exception but returns null --- .../gst-android-hardware-camera.c | 41 ++++++++++--------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index fada85e6f9..e77c473fc9 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -1790,15 +1790,16 @@ gst_ah_camera_get_parameters (GstAHCamera * self) GstAHCParameters *params = NULL; object = AHC_CALL (return NULL, Object, getParameters); - - params = g_slice_new0 (GstAHCParameters); - params->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!params->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAHCParameters, params); - return NULL; + if (object) { + params = g_slice_new0 (GstAHCParameters); + params->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!params->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCParameters, params); + return NULL; + } } return params; @@ -1822,20 +1823,20 @@ gst_ah_camera_open (gint camera_id) GstAHCamera *camera = NULL; object = AHC_STATIC_CALL (goto done, Object, open, camera_id); - - camera = g_slice_new0 (GstAHCamera); - camera->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!camera->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAHCamera, camera); - goto done; + if (object) { + camera = g_slice_new0 (GstAHCamera); + camera->object = (*env)->NewGlobalRef (env, object); + (*env)->DeleteLocalRef (env, object); + if (!camera->object) { + GST_ERROR ("Failed to create global reference"); + (*env)->ExceptionClear (env); + g_slice_free (GstAHCamera, camera); + camera = NULL; + } } - return camera; done: - return NULL; + return camera; } gboolean From 81c07b54cd756531f2a39da924df7648201eb752 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 7 Jan 2013 18:18:18 -0500 Subject: [PATCH 75/82] gstdvm: Fix GST_DVM_GET_STATIC_FIELD --- gst-libs/gst/dvm/gstdvm.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gst-libs/gst/dvm/gstdvm.h b/gst-libs/gst/dvm/gstdvm.h index b91e7fc627..1f4b6dee97 100644 --- a/gst-libs/gst/dvm/gstdvm.h +++ b/gst-libs/gst/dvm/gstdvm.h @@ -132,7 +132,7 @@ } #define GST_DVM_STATIC_FIELD(error_statement, type, k, field) \ - (*env)->Get##type##Field (env, k.klass, k.field); \ + (*env)->GetStatic##type##Field (env, k.klass, k.field); \ if ((*env)->ExceptionCheck (env)) { \ GST_ERROR ("Failed to get Java static field"); \ (*env)->ExceptionDescribe (env); \ From 86f2535c41b639c23575cffc0d923e215c3c20d2 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 7 Jan 2013 18:19:28 -0500 Subject: [PATCH 76/82] androidmedia: Add extern gint declarations --- .../gst-android-media-mediacodec.c | 10 ++++++++++ .../gst-android-media-mediacodec.h | 2 +- .../gst-android-media-mediacodecinfo.c | 20 +++++++++++++++++++ 3 files changed, 31 insertions(+), 1 deletion(-) diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c index f87669c30d..c676efd752 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ b/sys/androidmedia/gst-android-media-mediacodec.c @@ -65,6 +65,16 @@ static struct jint INFO_OUTPUT_BUFFERS_CHANGED; } android_media_mediacodec; +gint MediaCodec_BUFFER_FLAG_SYNC_FRAME; +gint MediaCodec_BUFFER_FLAG_CODEC_CONFIG; +gint MediaCodec_BUFFER_FLAG_END_OF_STREAM; + +gint MediaCodec_CONFIGURE_FLAG_ENCODE; + +gint MediaCodec_INFO_TRY_AGAIN_LATER; +gint MediaCodec_INFO_OUTPUT_FORMAT_CHANGED; +gint MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED; + static gboolean _init_classes (void) { diff --git a/sys/androidmedia/gst-android-media-mediacodec.h b/sys/androidmedia/gst-android-media-mediacodec.h index 2745eea293..709d0b720c 100644 --- a/sys/androidmedia/gst-android-media-mediacodec.h +++ b/sys/androidmedia/gst-android-media-mediacodec.h @@ -56,7 +56,7 @@ extern gint MediaCodec_BUFFER_FLAG_SYNC_FRAME; extern gint MediaCodec_BUFFER_FLAG_CODEC_CONFIG; extern gint MediaCodec_BUFFER_FLAG_END_OF_STREAM; -extern gint MediaCodec_CONFIGURE_FLAG_ENCODE; +extern gint MediaCodec_CONFIGURE_FLAG_ENCODE; extern gint MediaCodec_INFO_TRY_AGAIN_LATER; extern gint MediaCodec_INFO_OUTPUT_FORMAT_CHANGED; diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.c b/sys/androidmedia/gst-android-media-mediacodecinfo.c index 86df3e0f98..997c90ab7e 100644 --- a/sys/androidmedia/gst-android-media-mediacodecinfo.c +++ b/sys/androidmedia/gst-android-media-mediacodecinfo.c @@ -74,6 +74,26 @@ static struct jint CHANNEL_OUT_TOP_BACK_RIGHT; } android_media_audioformat; +gint AudioFormat_CHANNEL_OUT_FRONT_LEFT; +gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT; +gint AudioFormat_CHANNEL_OUT_FRONT_CENTER; +gint AudioFormat_CHANNEL_OUT_LOW_FREQUENCY; +gint AudioFormat_CHANNEL_OUT_BACK_LEFT; +gint AudioFormat_CHANNEL_OUT_BACK_RIGHT; +gint AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER; +gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; +gint AudioFormat_CHANNEL_OUT_BACK_CENTER; +gint AudioFormat_CHANNEL_OUT_SIDE_LEFT; +gint AudioFormat_CHANNEL_OUT_SIDE_RIGHT; +gint AudioFormat_CHANNEL_OUT_TOP_CENTER; +gint AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT; +gint AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER; +gint AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT; +gint AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT; +gint AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER; +gint AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT; + + static gboolean _init_classes (void) { From c84878ad4b967464698e0196e4d6ee326eb6cca7 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 7 Jan 2013 18:20:47 -0500 Subject: [PATCH 77/82] androidmedia: Fix get_level and get_profile exception checking by not using return --- sys/androidmedia/gst-android-media-mediacodecinfo.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.c b/sys/androidmedia/gst-android-media-mediacodecinfo.c index 997c90ab7e..abaec7326a 100644 --- a/sys/androidmedia/gst-android-media-mediacodecinfo.c +++ b/sys/androidmedia/gst-android-media-mediacodecinfo.c @@ -498,14 +498,20 @@ gint gst_am_mediacodecprofilelevel_get_level (GstAmMediaCodecProfileLevel * self) { JNIEnv *env = gst_dvm_get_env (); + gint ret; - return AMMCPL_FIELD (return -1, Int, level); + ret = AMMCPL_FIELD (return -1, Int, level); + + return ret; } gint gst_am_mediacodecprofilelevel_get_profile (GstAmMediaCodecProfileLevel * self) { JNIEnv *env = gst_dvm_get_env (); + gint ret; - return AMMCPL_FIELD (return -1, Int, profile); + ret = AMMCPL_FIELD (return -1, Int, profile); + + return ret; } From fe288a847b0bf9101765b5bb325bbf7cd1e253bc Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Mon, 7 Jan 2013 18:27:40 -0500 Subject: [PATCH 78/82] androidcamera: Separate release and free APIs --- sys/androidcamera/gst-android-graphics-surfacetexture.c | 6 ++++++ sys/androidcamera/gst-android-graphics-surfacetexture.h | 1 + sys/androidcamera/gst-android-hardware-camera.c | 7 +++++++ sys/androidcamera/gst-android-hardware-camera.h | 1 + sys/androidcamera/gstahcsrc.c | 5 ++++- 5 files changed, 19 insertions(+), 1 deletion(-) diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidcamera/gst-android-graphics-surfacetexture.c index 06a29453fa..709121fac2 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.c +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.c @@ -108,6 +108,12 @@ gst_ag_surfacetexture_release (GstAGSurfaceTexture * self) JNIEnv *env = gst_dvm_get_env (); GST_DVM_CALL (, self->object, Void, android_graphics_surfacetexture, release); +} + +void +gst_ag_surfacetexture_free (GstAGSurfaceTexture * self) +{ + JNIEnv *env = gst_dvm_get_env (); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAGSurfaceTexture, self); diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.h b/sys/androidcamera/gst-android-graphics-surfacetexture.h index 6ed04d8642..a9904d9798 100644 --- a/sys/androidcamera/gst-android-graphics-surfacetexture.h +++ b/sys/androidcamera/gst-android-graphics-surfacetexture.h @@ -43,6 +43,7 @@ void gst_android_graphics_surfacetexture_deinit (void); /* android.graphics.SurfaceTexture */ GstAGSurfaceTexture *gst_ag_surfacetexture_new (gint texture_id); void gst_ag_surfacetexture_release (GstAGSurfaceTexture *self); +void gst_ag_surfacetexture_free (GstAGSurfaceTexture *self); G_END_DECLS diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidcamera/gst-android-hardware-camera.c index e77c473fc9..59bdfd4da8 100644 --- a/sys/androidcamera/gst-android-hardware-camera.c +++ b/sys/androidcamera/gst-android-hardware-camera.c @@ -1855,11 +1855,18 @@ gst_ah_camera_release (GstAHCamera * self) JNIEnv *env = gst_dvm_get_env (); AHC_CALL (, Void, release); +} + +void +gst_ah_camera_release (GstAHCamera * self) +{ + JNIEnv *env = gst_dvm_get_env (); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAHCamera, self); } + gboolean gst_ah_camera_set_parameters (GstAHCamera * self, GstAHCParameters * params) { diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidcamera/gst-android-hardware-camera.h index aeffe71d63..03db671df4 100644 --- a/sys/androidcamera/gst-android-hardware-camera.h +++ b/sys/androidcamera/gst-android-hardware-camera.h @@ -139,6 +139,7 @@ gboolean gst_ah_camera_lock (GstAHCamera * self); GstAHCamera *gst_ah_camera_open (gint camera_id); gboolean gst_ah_camera_reconnect (GstAHCamera * self); void gst_ah_camera_release (GstAHCamera * self); +void gst_ah_camera_free (GstAHCamera * self); gboolean gst_ah_camera_set_parameters (GstAHCamera * self, GstAHCParameters * params); gboolean gst_ah_camera_set_error_callback (GstAHCamera * self, diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidcamera/gstahcsrc.c index 7ed1f22973..a61c60b780 100644 --- a/sys/androidcamera/gstahcsrc.c +++ b/sys/androidcamera/gstahcsrc.c @@ -2308,11 +2308,14 @@ gst_ahc_src_close (GstAHCSrc * self) gst_ah_camera_set_error_callback (self->camera, NULL, NULL); gst_ah_camera_set_preview_callback_with_buffer (self->camera, NULL, NULL); gst_ah_camera_release (self->camera); + gst_ah_camera_free (self->camera); } self->camera = NULL; - if (self->texture) + if (self->texture) { gst_ag_surfacetexture_release (self->texture); + gst_ag_surfacetexture_free (self->texture); + } self->texture = NULL; } From becaf2852df51d0d3ed63164a73471f753e8baba Mon Sep 17 00:00:00 2001 From: Justin Kim Date: Thu, 24 Dec 2015 12:14:24 +0900 Subject: [PATCH 79/82] move androidcamera into androidmedia This commit is a part of portng android hardware camera from 0.10 implementation. To preserve history and get diff clearly, the interesting files are moved to deployment directory and the remaining files are removed. --- gst-libs/gst/dvm/Makefile.am | 28 --- gst-libs/gst/dvm/gstdvm.c | 165 ------------------ gst-libs/gst/dvm/gstdvm.h | 147 ---------------- pkgconfig/gstreamer-dvm-uninstalled.pc.in | 12 -- pkgconfig/gstreamer-dvm.pc.in | 12 -- sys/androidcamera/Makefile.am | 76 -------- .../com/gstreamer/GstAhcCallback.java | 37 ---- sys/androidcamera/gstahccallback.h | 33 ---- .../gst-android-graphics-imageformat.c | 0 .../gst-android-graphics-imageformat.h | 0 .../gst-android-graphics-surfacetexture.c | 0 .../gst-android-graphics-surfacetexture.h | 0 .../gst-android-hardware-camera.c | 0 .../gst-android-hardware-camera.h | 0 .../gst-androidcamera.c | 0 .../gstahcsrc.c | 0 .../gstahcsrc.h | 0 17 files changed, 510 deletions(-) delete mode 100644 gst-libs/gst/dvm/Makefile.am delete mode 100644 gst-libs/gst/dvm/gstdvm.c delete mode 100644 gst-libs/gst/dvm/gstdvm.h delete mode 100644 pkgconfig/gstreamer-dvm-uninstalled.pc.in delete mode 100644 pkgconfig/gstreamer-dvm.pc.in delete mode 100644 sys/androidcamera/Makefile.am delete mode 100644 sys/androidcamera/com/gstreamer/GstAhcCallback.java delete mode 100644 sys/androidcamera/gstahccallback.h rename sys/{androidcamera => androidmedia}/gst-android-graphics-imageformat.c (100%) rename sys/{androidcamera => androidmedia}/gst-android-graphics-imageformat.h (100%) rename sys/{androidcamera => androidmedia}/gst-android-graphics-surfacetexture.c (100%) rename sys/{androidcamera => androidmedia}/gst-android-graphics-surfacetexture.h (100%) rename sys/{androidcamera => androidmedia}/gst-android-hardware-camera.c (100%) rename sys/{androidcamera => androidmedia}/gst-android-hardware-camera.h (100%) rename sys/{androidcamera => androidmedia}/gst-androidcamera.c (100%) rename sys/{androidcamera => androidmedia}/gstahcsrc.c (100%) rename sys/{androidcamera => androidmedia}/gstahcsrc.h (100%) diff --git a/gst-libs/gst/dvm/Makefile.am b/gst-libs/gst/dvm/Makefile.am deleted file mode 100644 index 3da6f8616c..0000000000 --- a/gst-libs/gst/dvm/Makefile.am +++ /dev/null @@ -1,28 +0,0 @@ -lib_LTLIBRARIES = libgstdvm-@GST_MAJORMINOR@.la -libgstdvmincludedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/dvm - -libgstdvminclude_HEADERS = \ - gstdvm.h - -libgstdvm_@GST_MAJORMINOR@_la_SOURCES = \ - gstdvm.c - -libgstdvm_@GST_MAJORMINOR@_la_CFLAGS = \ - $(GST_PLUGINS_BAD_CFLAGS) \ - $(GST_CFLAGS) -libgstdvm_@GST_MAJORMINOR@_la_LIBADD = $(GST_LIBS) -libgstdvm_@GST_MAJORMINOR@_la_LDFLAGS = $(GST_LIB_LDFLAGS) $(GST_ALL_LDFLAGS) $(GST_LT_LDFLAGS) - -Android.mk: $(BUILT_SOURCES) Makefile.am - androgenizer -:PROJECT libgstdvm -:STATIC libgstdvm-@GST_MAJORMINOR@ \ - -:TAGS eng debug \ - -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \ - -:SOURCES $(libgstdvm_@GST_MAJORMINOR@_la_SOURCES) \ - -:CFLAGS $(DEFS) $(libgstdvm_@GST_MAJORMINOR@_la_CFLAGS) \ - -:LDFLAGS $(libgstdvm_@GST_MAJORMINOR@_la_LDFLAGS) \ - $(libgstdvm_@GST_MAJORMINOR@_la_LIBADD) \ - -ldl \ - -:HEADER_TARGET gstreamer-@GST_MAJORMINOR@/gst/dvm \ - -:HEADERS $(libgstdvminclude_HEADERS) - -:PASSTHROUGH LOCAL_ARM_MODE:=arm \ - > $@ diff --git a/gst-libs/gst/dvm/gstdvm.c b/gst-libs/gst/dvm/gstdvm.c deleted file mode 100644 index 82dea7b750..0000000000 --- a/gst-libs/gst/dvm/gstdvm.c +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Copyright (C) 2012, Cisco Systems, Inc. - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include "gstdvm.h" - -#include - -GST_DEBUG_CATEGORY (gst_dvm_debug); -#define GST_CAT_DEFAULT gst_dvm_debug - -static GModule *java_module; -static jint (*get_created_java_vms) (JavaVM ** vmBuf, jsize bufLen, - jsize * nVMs); -static jint (*create_java_vm) (JavaVM ** p_vm, JNIEnv ** p_env, void *vm_args); -static JavaVM *java_vm = NULL; -static gboolean started_java_vm = FALSE; - -static pthread_key_t current_jni_env; - -static JNIEnv * -gst_dvm_attach_current_thread (void) -{ - JNIEnv *env; - JavaVMAttachArgs args; - - GST_DEBUG ("Attaching thread %p", g_thread_self ()); - args.version = JNI_VERSION_1_6; - 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 -gst_dvm_detach_current_thread (void *env) -{ - GST_DEBUG ("Detaching thread %p", g_thread_self ()); - (*java_vm)->DetachCurrentThread (java_vm); -} - -JNIEnv * -gst_dvm_get_env (void) -{ - JNIEnv *env; - - if ((env = pthread_getspecific (current_jni_env)) == NULL) { - env = gst_dvm_attach_current_thread (); - pthread_setspecific (current_jni_env, env); - } - - return env; -} - -gboolean -gst_dvm_init (void) -{ - jsize n_vms; - - GST_DEBUG_CATEGORY_INIT (gst_dvm_debug, "dvm", 0, "DVM"); - - pthread_key_create (¤t_jni_env, gst_dvm_detach_current_thread); - - java_module = g_module_open ("libdvm", G_MODULE_BIND_LOCAL); - if (!java_module) - goto load_failed; - - if (!g_module_symbol (java_module, "JNI_CreateJavaVM", - (gpointer *) & create_java_vm)) - goto symbol_error; - - if (!g_module_symbol (java_module, "JNI_GetCreatedJavaVMs", - (gpointer *) & get_created_java_vms)) - goto symbol_error; - - n_vms = 0; - if (get_created_java_vms (&java_vm, 1, &n_vms) < 0) - goto get_created_failed; - - if (n_vms > 0) { - GST_DEBUG ("Successfully got existing Java VM %p", java_vm); - } else { - JNIEnv *env; - JavaVMInitArgs vm_args; - JavaVMOption options[4]; - - options[0].optionString = "-verbose:jni"; - options[1].optionString = "-verbose:gc"; - options[2].optionString = "-Xcheck:jni"; - options[3].optionString = "-Xdebug"; - - vm_args.version = JNI_VERSION_1_4; - vm_args.options = options; - vm_args.nOptions = 4; - vm_args.ignoreUnrecognized = JNI_TRUE; - if (create_java_vm (&java_vm, &env, &vm_args) < 0) - goto create_failed; - GST_DEBUG ("Successfully created Java VM %p", java_vm); - - started_java_vm = TRUE; - } - - return java_vm != NULL; - -load_failed: - { - GST_ERROR ("Failed to load libdvm: %s", g_module_error ()); - return FALSE; - } -symbol_error: - { - GST_ERROR ("Failed to locate required JNI symbols in libdvm: %s", - g_module_error ()); - g_module_close (java_module); - java_module = NULL; - return FALSE; - } -get_created_failed: - { - GST_ERROR ("Failed to get already created VMs"); - g_module_close (java_module); - java_module = NULL; - return FALSE; - } -create_failed: - { - GST_ERROR ("Failed to create a Java VM"); - g_module_close (java_module); - java_module = NULL; - return FALSE; - } -} - -gboolean -gst_dvm_is_own_vm (void) -{ - return started_java_vm; -} diff --git a/gst-libs/gst/dvm/gstdvm.h b/gst-libs/gst/dvm/gstdvm.h deleted file mode 100644 index 1f4b6dee97..0000000000 --- a/gst-libs/gst/dvm/gstdvm.h +++ /dev/null @@ -1,147 +0,0 @@ -/* Dalvik Virtual Machine helper functions - * - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Copyright (C) 2012, Cisco Systems, Inc. - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __GST_DVM_H__ -#define __GST_DVM_H__ - -#include -#include - -#define GST_DVM_GET_CLASS(k, name) { \ - jclass tmp; \ - \ - tmp = (*env)->FindClass (env, name); \ - if (!tmp) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get class %s", name); \ - return FALSE; \ - } \ - \ - k.klass = (*env)->NewGlobalRef (env, tmp); \ - if (!k.klass) { \ - (*env)->ExceptionClear (env); \ - (*env)->DeleteLocalRef (env, tmp); \ - GST_ERROR ("Failed to get %s class global reference", name); \ - return FALSE; \ - } \ - (*env)->DeleteLocalRef (env, tmp); \ - } -#define GST_DVM_GET_STATIC_METHOD(k, method, signature) \ - k.method = (*env)->GetStaticMethodID (env, k.klass, #method, \ - signature); \ - if (!k.method) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get static method %s for %s", #method, #k); \ - return FALSE; \ - } - -#define GST_DVM_GET_METHOD(k, method, signature) \ - k.method = (*env)->GetMethodID (env, k.klass, #method, signature); \ - if (!k.method) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get method %s for %s", #method, #k); \ - return FALSE; \ - } - -#define GST_DVM_GET_CONSTRUCTOR(k, field, signature) \ - k.field = (*env)->GetMethodID (env, k.klass, "", signature); \ - if (!k.field) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get constructor %s for %s", #field, #k); \ - return FALSE; \ - } - -#define GST_DVM_GET_STATIC_FIELD(k, field, signature) \ - k.field = (*env)->GetStaticFieldID (env, k.klass, #field, signature); \ - if (!k.field) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get static field %s for %s", #field, #k); \ - return FALSE; \ - } - -#define GST_DVM_GET_FIELD(k, field, signature) \ - k.field = (*env)->GetFieldID (env, k.klass, #field, signature); \ - if (!k.field) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get field %s for %s", #field, #k); \ - return FALSE; \ - } - -#define GST_DVM_GET_CONSTANT(k, field, type, signature) { \ - jfieldID id; \ - \ - id = (*env)->GetStaticFieldID (env, k.klass, #field, signature); \ - if (!id) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get static field %s for %s", #field, #k); \ - return FALSE; \ - } \ - k.field = (*env)->GetStatic##type##Field (env, k.klass, id); \ - if ((*env)->ExceptionCheck (env)) { \ - (*env)->ExceptionClear (env); \ - GST_ERROR ("Failed to get " #type " constant %s", #field); \ - return FALSE; \ - } \ - } - -#define GST_DVM_STATIC_CALL(error_statement, type, k, method, ...) \ - (*env)->CallStatic##type##Method (env, k.klass, k.method, ## __VA_ARGS__); \ - if ((*env)->ExceptionCheck (env)) { \ - GST_ERROR ("Failed to call Java method"); \ - (*env)->ExceptionDescribe (env); \ - (*env)->ExceptionClear (env); \ - error_statement; \ - } - -#define GST_DVM_CALL(error_statement, obj, type, k, method, ...) \ - (*env)->Call##type##Method (env, obj, k.method, ## __VA_ARGS__); \ - if ((*env)->ExceptionCheck (env)) { \ - GST_ERROR ("Failed to call Java method"); \ - (*env)->ExceptionDescribe (env); \ - (*env)->ExceptionClear (env); \ - error_statement; \ - } - -#define GST_DVM_FIELD(error_statement, obj, type, k, field) \ - (*env)->Get##type##Field (env, obj, k.field); \ - if ((*env)->ExceptionCheck (env)) { \ - GST_ERROR ("Failed to get Java field"); \ - (*env)->ExceptionDescribe (env); \ - (*env)->ExceptionClear (env); \ - error_statement; \ - } - -#define GST_DVM_STATIC_FIELD(error_statement, type, k, field) \ - (*env)->GetStatic##type##Field (env, k.klass, k.field); \ - if ((*env)->ExceptionCheck (env)) { \ - GST_ERROR ("Failed to get Java static field"); \ - (*env)->ExceptionDescribe (env); \ - (*env)->ExceptionClear (env); \ - error_statement; \ - } - -JNIEnv *gst_dvm_get_env (void); -gboolean gst_dvm_init (void); -gboolean gst_dvm_is_own_vm (void); - -#endif /* __GST_DVM_H__ */ diff --git a/pkgconfig/gstreamer-dvm-uninstalled.pc.in b/pkgconfig/gstreamer-dvm-uninstalled.pc.in deleted file mode 100644 index c1de57e9bf..0000000000 --- a/pkgconfig/gstreamer-dvm-uninstalled.pc.in +++ /dev/null @@ -1,12 +0,0 @@ -prefix= -exec_prefix= -libdir=${pcfiledir}/../gst-libs/gst/dvm -includedir=${pcfiledir}/../gst-libs - -Name: GStreamer DVM, Uninstalled -Description: Dalvik Virtual Machine helpers, Uninstalled -Requires: gstreamer-@GST_MAJORMINOR@ -Version: @VERSION@ -Libs: -L${libdir} ${libdir}/libgstdvm-@GST_MAJORMINOR@.la -Cflags: -I${includedir} - diff --git a/pkgconfig/gstreamer-dvm.pc.in b/pkgconfig/gstreamer-dvm.pc.in deleted file mode 100644 index a3203a5fd1..0000000000 --- a/pkgconfig/gstreamer-dvm.pc.in +++ /dev/null @@ -1,12 +0,0 @@ -prefix=@prefix@ -exec_prefix=@exec_prefix@ -libdir=@libdir@ -includedir=@includedir@/gstreamer-@GST_MAJORMINOR@ - -Name: GStreamer DVM -Description: Dalvik Virtual Machine helpers -Requires: gstreamer-@GST_MAJORMINOR@ -Version: @VERSION@ -Libs: -L${libdir} -lgstdvm-@GST_MAJORMINOR@ -Cflags: -I${includedir} - diff --git a/sys/androidcamera/Makefile.am b/sys/androidcamera/Makefile.am deleted file mode 100644 index e24e94404f..0000000000 --- a/sys/androidcamera/Makefile.am +++ /dev/null @@ -1,76 +0,0 @@ -plugin_LTLIBRARIES = libgstandroidcamera.la - -libgstandroidcamera_la_SOURCES = \ - gst-androidcamera.c \ - gst-android-hardware-camera.c \ - gst-android-graphics-surfacetexture.c \ - gst-android-graphics-imageformat.c \ - gstahcsrc.c \ - gstahccallback.c - -JAVA_SOURCE = com/gstreamer/GstAhcCallback.java - -noinst_HEADERS = \ - gstahcsrc.h \ - gstahccallback.h \ - gst-android-hardware-camera.h \ - gst-android-graphics-surfacetexture.h \ - gst-android-graphics-imageformat.h - -libgstandroidcamera_la_CFLAGS = \ - $(GST_PLUGINS_BAD_CFLAGS) \ - $(GST_PLUGINS_BASE_CFLAGS) \ - $(GST_BASE_CFLAGS) \ - $(GST_CFLAGS) \ - -I$(srcdir) -libgstandroidcamera_la_LIBADD = \ - $(GST_PLUGINS_BASE_LIBS) \ - $(GST_BASE_LIBS) \ - $(GST_LIBS) \ - $(top_builddir)/gst-libs/gst/dvm/libgstdvm-@GST_MAJORMINOR@.la -libgstandroidcamera_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -libgstandroidcamera_la_LIBTOOLFLAGS = --tag=disable-static - -EXTRA_DIST = $(JAVA_SOURCE) -CLEANFILES = gstahccallback.c - -if HAVE_ANDROID_SDK -gstahccallback.c: $(JAVA_SOURCE) - @echo -e " JAVAC\t $(JAVA_SOURCE)" - @$(JAVAC) -target 1.6 -source 1.6 -nowarn \ - -classpath $(ANDROID_SDK_DIR)/platforms/android-$(ANDROID_PLATFORM)/android.jar $(JAVA_SOURCE) - @echo -e " DEX\t $(JAVA_SOURCE:.java=.class)" - @$(DX) --dex --output GstAhcCallback.jar $(JAVA_SOURCE:.java=.class) - @echo -e " GEN\t $@" - @echo "#include \"gstahccallback.h\"" > $@ - @echo "" >> $@ - @echo "const static guint8 jar_file[] = {" >> $@ - @hexdump -v -e '" "' -e '8/1 "0x%02x, "' -e '"\n"' GstAhcCallback.jar | sed 's/0x ,//g' >> $@ - @echo "};" >> $@ - @echo "" >> $@ - @echo "const guint8 *gst_ahc_callback_jar = jar_file;" >> $@ - @echo "const gsize gst_ahc_callback_jar_size = sizeof(jar_file);" >> $@ - @rm -f GstAhcCallback.jar -else -gstahccallback.c: - @echo -e " GEN\t $@" - @echo "#include \"gstahccallback.h\"" > $@ - @echo "" >> $@ - @echo "const guint8 *gst_ahc_callback_jar = NULL;" >> $@ - @echo "const gsize gst_ahc_callback_jar_size = 0;" >> $@ -endif - -Android.mk: Makefile.am $(BUILT_SOURCES) - androgenizer \ - -:PROJECT libgstandroidcamera -:SHARED libgstandroidcamera \ - -:TAGS eng debug \ - -:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \ - -:SOURCES $(libgstandroidcamera_la_SOURCES) \ - $(libgstandroidcamera_la_SOURCES) \ - -:CFLAGS $(DEFS) $(DEFAULT_INCLUDES) $(libgstandroidcamera_la_CFLAGS) \ - -:LDFLAGS $(libgstandroidcamera_la_LDFLAGS) \ - $(libgstandroidcamera_la_LIBADD) \ - -ldl \ - -:PASSTHROUGH LOCAL_ARM_MODE:=arm \ - LOCAL_MODULE_PATH:='$$(TARGET_OUT)/lib/gstreamer-@GST_MAJOR_MINOR@' \ - > $@ diff --git a/sys/androidcamera/com/gstreamer/GstAhcCallback.java b/sys/androidcamera/com/gstreamer/GstAhcCallback.java deleted file mode 100644 index 0763d91f6e..0000000000 --- a/sys/androidcamera/com/gstreamer/GstAhcCallback.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.gstreamer; - -import android.hardware.Camera; - -public class GstAhcCallback implements Camera.PreviewCallback, - Camera.ErrorCallback, - Camera.AutoFocusCallback { - public long mUserData; - public long mCallback; - - public static native void gst_ah_camera_on_preview_frame(byte[] data, Camera camera, - long callback, long user_data); - public static native void gst_ah_camera_on_error(int error, Camera camera, - long callback, long user_data); - public static native void gst_ah_camera_on_auto_focus(boolean success, Camera camera, - long callback, long user_data); - - public GstAhcCallback(long callback, long user_data) { - mCallback = callback; - mUserData = user_data; - } - - @Override - public void onPreviewFrame(byte[] data, Camera camera) { - gst_ah_camera_on_preview_frame(data, camera, mCallback, mUserData); - } - - @Override - public void onError(int error, Camera camera) { - gst_ah_camera_on_error(error, camera, mCallback, mUserData); - } - - @Override - public void onAutoFocus(boolean success, Camera camera) { - gst_ah_camera_on_auto_focus(success, camera, mCallback, mUserData); - } -} diff --git a/sys/androidcamera/gstahccallback.h b/sys/androidcamera/gstahccallback.h deleted file mode 100644 index df4d6d20bf..0000000000 --- a/sys/androidcamera/gstahccallback.h +++ /dev/null @@ -1,33 +0,0 @@ -/* com/gstreamer/GstAhcCallbac.java wrapper header - * - * Copyright (C) 2012, Cisco Systems, Inc. - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -#ifndef __GST_AHC_CALLBACK_H__ -#define __GST_AHC_CALLBACK_H__ - -#include - -G_BEGIN_DECLS - -extern const guint8 *gst_ahc_callback_jar; -extern const gsize gst_ahc_callback_jar_size; - -G_END_DECLS -#endif /* __GST_AHC_CALLBACK_H__ */ diff --git a/sys/androidcamera/gst-android-graphics-imageformat.c b/sys/androidmedia/gst-android-graphics-imageformat.c similarity index 100% rename from sys/androidcamera/gst-android-graphics-imageformat.c rename to sys/androidmedia/gst-android-graphics-imageformat.c diff --git a/sys/androidcamera/gst-android-graphics-imageformat.h b/sys/androidmedia/gst-android-graphics-imageformat.h similarity index 100% rename from sys/androidcamera/gst-android-graphics-imageformat.h rename to sys/androidmedia/gst-android-graphics-imageformat.h diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.c b/sys/androidmedia/gst-android-graphics-surfacetexture.c similarity index 100% rename from sys/androidcamera/gst-android-graphics-surfacetexture.c rename to sys/androidmedia/gst-android-graphics-surfacetexture.c diff --git a/sys/androidcamera/gst-android-graphics-surfacetexture.h b/sys/androidmedia/gst-android-graphics-surfacetexture.h similarity index 100% rename from sys/androidcamera/gst-android-graphics-surfacetexture.h rename to sys/androidmedia/gst-android-graphics-surfacetexture.h diff --git a/sys/androidcamera/gst-android-hardware-camera.c b/sys/androidmedia/gst-android-hardware-camera.c similarity index 100% rename from sys/androidcamera/gst-android-hardware-camera.c rename to sys/androidmedia/gst-android-hardware-camera.c diff --git a/sys/androidcamera/gst-android-hardware-camera.h b/sys/androidmedia/gst-android-hardware-camera.h similarity index 100% rename from sys/androidcamera/gst-android-hardware-camera.h rename to sys/androidmedia/gst-android-hardware-camera.h diff --git a/sys/androidcamera/gst-androidcamera.c b/sys/androidmedia/gst-androidcamera.c similarity index 100% rename from sys/androidcamera/gst-androidcamera.c rename to sys/androidmedia/gst-androidcamera.c diff --git a/sys/androidcamera/gstahcsrc.c b/sys/androidmedia/gstahcsrc.c similarity index 100% rename from sys/androidcamera/gstahcsrc.c rename to sys/androidmedia/gstahcsrc.c diff --git a/sys/androidcamera/gstahcsrc.h b/sys/androidmedia/gstahcsrc.h similarity index 100% rename from sys/androidcamera/gstahcsrc.h rename to sys/androidmedia/gstahcsrc.h From f1809c4d938b6d7aebe1a8601930f3e057a629ba Mon Sep 17 00:00:00 2001 From: Justin Kim Date: Thu, 24 Dec 2015 12:51:13 +0900 Subject: [PATCH 80/82] ahcsrc: porting from 0.10 to 1.0 --- sys/androidmedia/Makefile.am | 31 +- .../gst-android-graphics-imageformat.c | 114 +- .../gst-android-graphics-imageformat.h | 5 +- .../gst-android-graphics-surfacetexture.c | 50 +- .../gst-android-graphics-surfacetexture.h | 3 + .../gst-android-hardware-camera.c | 1327 ++++++++++++----- .../gst-android-hardware-camera.h | 3 + .../gst-android-media-mediacodec.c | 531 ------- .../gst-android-media-mediacodec.h | 101 -- .../gst-android-media-mediacodecinfo.c | 517 ------- .../gst-android-media-mediacodecinfo.h | 91 -- .../gst-android-media-mediacodeclist.c | 116 -- .../gst-android-media-mediacodeclist.h | 40 - .../gst-android-media-mediaformat.c | 554 ------- .../gst-android-media-mediaformat.h | 75 - sys/androidmedia/gstahcsrc.c | 566 +++---- sys/androidmedia/gstahcsrc.h | 4 + sys/androidmedia/gstamc.c | 24 + .../androidmedia/GstAhcCallback.java | 60 + 19 files changed, 1490 insertions(+), 2722 deletions(-) delete mode 100644 sys/androidmedia/gst-android-media-mediacodec.c delete mode 100644 sys/androidmedia/gst-android-media-mediacodec.h delete mode 100644 sys/androidmedia/gst-android-media-mediacodecinfo.c delete mode 100644 sys/androidmedia/gst-android-media-mediacodecinfo.h delete mode 100644 sys/androidmedia/gst-android-media-mediacodeclist.c delete mode 100644 sys/androidmedia/gst-android-media-mediacodeclist.h delete mode 100644 sys/androidmedia/gst-android-media-mediaformat.c delete mode 100644 sys/androidmedia/gst-android-media-mediaformat.h create mode 100644 sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java diff --git a/sys/androidmedia/Makefile.am b/sys/androidmedia/Makefile.am index a04b0ade57..7ad9b6e936 100644 --- a/sys/androidmedia/Makefile.am +++ b/sys/androidmedia/Makefile.am @@ -1,22 +1,30 @@ plugin_LTLIBRARIES = libgstandroidmedia.la libgstandroidmedia_la_SOURCES = \ - gstamc.c \ + gstahcsrc.c \ gstamcaudiodec.c \ - gstamcvideodec.c \ - gstamcvideoenc.c \ + gstamc.c \ gstamcsurface.c \ gstamcsurfacetexture.c \ + gstamcvideodec.c \ + gstamcvideoenc.c \ + gst-android-graphics-imageformat.c \ + gst-android-graphics-surfacetexture.c \ + gst-android-hardware-camera.c \ gstjniutils.c noinst_HEADERS = \ - gstamc.h \ - gstamc-constants.h \ + gstahcsrc.h \ gstamcaudiodec.h \ - gstamcvideodec.h \ - gstamcvideoenc.h \ + gstamc-constants.h \ + gstamc.h \ gstamcsurface.h \ gstamcsurfacetexture.h \ + gstamcvideodec.h \ + gstamcvideoenc.h \ + gst-android-graphics-imageformat.h \ + gst-android-graphics-surfacetexture.h \ + gst-android-hardware-camera.h \ gstjniutils.h libgstandroidmedia_la_CFLAGS = \ @@ -25,8 +33,11 @@ libgstandroidmedia_la_CFLAGS = \ $(GST_PLUGINS_BASE_CFLAGS) \ $(GST_BASE_CFLAGS) \ $(GST_CFLAGS) \ - $(ORC_CFLAGS) + $(ORC_CFLAGS) \ + -DGST_USE_UNSTABLE_API + libgstandroidmedia_la_LIBADD = \ + $(top_builddir)/gst-libs/gst/interfaces/libgstphotography-$(GST_API_VERSION).la \ $(top_builddir)/gst-libs/gst/gl/libgstgl-$(GST_API_VERSION).la \ $(GST_PLUGINS_BASE_LIBS) \ -lgstaudio-@GST_API_VERSION@ \ @@ -39,4 +50,6 @@ libgstandroidmedia_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) libgstandroidmedia_la_LIBTOOLFLAGS = $(GST_PLUGIN_LIBTOOLFLAGS) androidmedia_java_classesdir = $(datadir)/gst-android/ndk-build/androidmedia/ -androidmedia_java_classes_DATA = org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java +androidmedia_java_classes_DATA = \ + org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java \ + org/freedesktop/gstreamer/androidmedia/GstAmcOnFrameAvailableListener.java diff --git a/sys/androidmedia/gst-android-graphics-imageformat.c b/sys/androidmedia/gst-android-graphics-imageformat.c index 577131f27b..a382e5827b 100644 --- a/sys/androidmedia/gst-android-graphics-imageformat.c +++ b/sys/androidmedia/gst-android-graphics-imageformat.c @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation @@ -23,7 +26,7 @@ #include "config.h" #endif -#include +#include "gstjniutils.h" #include "gst-android-graphics-imageformat.h" @@ -31,7 +34,7 @@ static struct { jclass klass; - jmethodID getBitsPerPixel; + jmethodID get_bits_per_pixel; jint JPEG; jint NV16; jint NV21; @@ -53,30 +56,95 @@ gint ImageFormat_YV12; static gboolean _init_classes (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env; + + jfieldID fieldID; + jclass klass; + + GError *err = NULL; + + env = gst_amc_jni_get_env (); /* android.graphics.ImageFormat */ - GST_DVM_GET_CLASS (android_graphics_imageformat, - "android/graphics/ImageFormat"); - GST_DVM_GET_STATIC_METHOD (android_graphics_imageformat, getBitsPerPixel, - "(I)I"); + klass = android_graphics_imageformat.klass = + gst_amc_jni_get_class (env, &err, "android/graphics/ImageFormat"); - GST_DVM_GET_CONSTANT (android_graphics_imageformat, JPEG, Int, "I"); + if (err) + goto failed; + + android_graphics_imageformat.get_bits_per_pixel = + gst_amc_jni_get_static_method_id (env, &err, klass, + "getBitsPerPixel", "(I)I"); + + if (err) + goto failed; + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "JPEG", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.JPEG)) + goto failed; ImageFormat_JPEG = android_graphics_imageformat.JPEG; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, NV16, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "NV16", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.NV16)) + goto failed; ImageFormat_NV16 = android_graphics_imageformat.NV16; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, NV21, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "NV21", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.NV21)) + goto failed; ImageFormat_NV21 = android_graphics_imageformat.NV21; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, RGB_565, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "RGB_565", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.RGB_565)) + goto failed; ImageFormat_RGB_565 = android_graphics_imageformat.RGB_565; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, UNKNOWN, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "UNKNOWN", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.UNKNOWN)) + goto failed; ImageFormat_UNKNOWN = android_graphics_imageformat.UNKNOWN; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, YUY2, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "YUY2", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.YUY2)) + goto failed; ImageFormat_YUY2 = android_graphics_imageformat.YUY2; - GST_DVM_GET_CONSTANT (android_graphics_imageformat, YV12, Int, "I"); + + fieldID = gst_amc_jni_get_static_field_id (env, &err, klass, "YV12", "I"); + if (err) + goto failed; + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_graphics_imageformat.YV12)) + goto failed; ImageFormat_YV12 = android_graphics_imageformat.YV12; return TRUE; + +failed: + if (err) { + GST_ERROR ("Failed to get android.graphics.ImageFormat class: %s", + err->message); + g_clear_error (&err); + } + + return FALSE; } gboolean @@ -93,7 +161,7 @@ gst_android_graphics_imageformat_init (void) void gst_android_graphics_imageformat_deinit (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); if (android_graphics_imageformat.klass) (*env)->DeleteGlobalRef (env, android_graphics_imageformat.klass); @@ -104,11 +172,21 @@ gst_android_graphics_imageformat_deinit (void) gint gst_ag_imageformat_get_bits_per_pixel (gint format) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env; + GError *err = NULL; + + jclass klass = android_graphics_imageformat.klass; + jint bpp = 0; - bpp = GST_DVM_STATIC_CALL (return -1, Int, - android_graphics_imageformat, getBitsPerPixel, format); + env = gst_amc_jni_get_env (); + + if (!gst_amc_jni_call_static_int_method (env, &err, + klass, android_graphics_imageformat.get_bits_per_pixel, &bpp, format)) { + GST_ERROR ("Failed to get android.graphics.ImageFormat class: %s", + err->message); + g_clear_error (&err); + } return bpp; } diff --git a/sys/androidmedia/gst-android-graphics-imageformat.h b/sys/androidmedia/gst-android-graphics-imageformat.h index 257a30408f..aff218b955 100644 --- a/sys/androidmedia/gst-android-graphics-imageformat.h +++ b/sys/androidmedia/gst-android-graphics-imageformat.h @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation @@ -23,8 +26,6 @@ #define __GST_ANDROID_GRAPHICS_IMAGEFORMAT_H__ #include -#include - G_BEGIN_DECLS diff --git a/sys/androidmedia/gst-android-graphics-surfacetexture.c b/sys/androidmedia/gst-android-graphics-surfacetexture.c index 709121fac2..84993a8c87 100644 --- a/sys/androidmedia/gst-android-graphics-surfacetexture.c +++ b/sys/androidmedia/gst-android-graphics-surfacetexture.c @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation @@ -23,11 +26,10 @@ #include "config.h" #endif -#include +#include "gstjniutils.h" #include "gst-android-graphics-surfacetexture.h" - static struct { jclass klass; @@ -39,14 +41,28 @@ static struct static gboolean _init_classes (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env; + GError *err = NULL; + + env = gst_amc_jni_get_env (); /* android.graphics.SurfaceTexture */ - GST_DVM_GET_CLASS (android_graphics_surfacetexture, - "android/graphics/SurfaceTexture"); - GST_DVM_GET_CONSTRUCTOR (android_graphics_surfacetexture, constructor, - "(I)V"); - GST_DVM_GET_METHOD (android_graphics_surfacetexture, release, "()V"); + android_graphics_surfacetexture.klass = + gst_amc_jni_get_class (env, &err, "android/graphics/SurfaceTexture"); + + if (!android_graphics_surfacetexture.klass) { + GST_ERROR ("Failed to get android.graphics.SurfaceTexture class: %s", + err->message); + g_clear_error (&err); + return FALSE; + } + + android_graphics_surfacetexture.constructor = + gst_amc_jni_get_method_id (env, &err, + android_graphics_surfacetexture.klass, "", "(I)V"); + android_graphics_surfacetexture.release = + gst_amc_jni_get_method_id (env, &err, + android_graphics_surfacetexture.klass, "release", "()V"); return TRUE; } @@ -65,7 +81,7 @@ gst_android_graphics_surfacetexture_init (void) void gst_android_graphics_surfacetexture_deinit (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); if (android_graphics_surfacetexture.klass) (*env)->DeleteGlobalRef (env, android_graphics_surfacetexture.klass); @@ -76,7 +92,7 @@ gst_android_graphics_surfacetexture_deinit (void) GstAGSurfaceTexture * gst_ag_surfacetexture_new (gint texture_id) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; GstAGSurfaceTexture *tex = NULL; @@ -105,15 +121,23 @@ gst_ag_surfacetexture_new (gint texture_id) void gst_ag_surfacetexture_release (GstAGSurfaceTexture * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env; + GError *err = NULL; + + env = gst_amc_jni_get_env (); + + if (!gst_amc_jni_call_void_method (env, &err, self->object, + android_graphics_surfacetexture.release)) { + GST_ERROR ("Failed to call release: %s", err->message); + g_clear_error (&err); + } - GST_DVM_CALL (, self->object, Void, android_graphics_surfacetexture, release); } void gst_ag_surfacetexture_free (GstAGSurfaceTexture * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAGSurfaceTexture, self); diff --git a/sys/androidmedia/gst-android-graphics-surfacetexture.h b/sys/androidmedia/gst-android-graphics-surfacetexture.h index a9904d9798..3bb80ca5d4 100644 --- a/sys/androidmedia/gst-android-graphics-surfacetexture.h +++ b/sys/androidmedia/gst-android-graphics-surfacetexture.h @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation diff --git a/sys/androidmedia/gst-android-hardware-camera.c b/sys/androidmedia/gst-android-hardware-camera.c index 59bdfd4da8..f28fe03252 100644 --- a/sys/androidmedia/gst-android-hardware-camera.c +++ b/sys/androidmedia/gst-android-hardware-camera.c @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation @@ -23,12 +26,34 @@ #include "config.h" #endif -#include +#include "gstjniutils.h" -#include "gstahccallback.h" #include "gst-android-hardware-camera.h" #include "stdio.h" +GST_DEBUG_CATEGORY_STATIC (ahc_debug); +#define GST_CAT_DEFAULT ahc_debug + +#define GST_DVM_STATIC_CALL(error_statement, type, k, method, ...) \ + (*env)->CallStatic##type##Method (env, k.klass, k.method, ## __VA_ARGS__); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to call Java method"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } + +#define GST_DVM_CALL(error_statement, obj, type, k, method, ...) \ + (*env)->Call##type##Method (env, obj, k.method, ## __VA_ARGS__); \ + if ((*env)->ExceptionCheck (env)) { \ + GST_ERROR ("Failed to call Java method"); \ + (*env)->ExceptionDescribe (env); \ + (*env)->ExceptionClear (env); \ + error_statement; \ + } + + + static struct { jclass klass; @@ -260,7 +285,7 @@ static struct { jclass klass; jmethodID constructor; -} com_gstreamer_gstahccallback = { +} org_freedesktop_gstreamer_androidmedia_gstahccallback = { 0}; static void @@ -300,163 +325,332 @@ static JNINativeMethod native_methods[] = { {(gchar *) "gst_ah_camera_on_error", (gchar *) "(ILandroid/hardware/Camera;JJ)V", (void *) gst_ah_camera_on_error}, - {(gchar *) "gst_ah_camera_on_auto_focus", - (gchar *) "(ZLandroid/hardware/Camera;JJ)V", - (void *) gst_ah_camera_on_auto_focus} +// {(gchar *) "gst_ah_camera_on_auto_focus", +// (gchar *) "(ZLandroid/hardware/Camera;JJ)V", +// (void *) gst_ah_camera_on_auto_focus} }; static gboolean _init_classes (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env; + GError *err; + + jclass klass; + jfieldID fieldID; + + env = gst_amc_jni_get_env (); /* android.hardware.Camera */ - GST_DVM_GET_CLASS (android_hardware_camera, "android/hardware/Camera"); - GST_DVM_GET_METHOD (android_hardware_camera, addCallbackBuffer, "([B)V"); - GST_DVM_GET_METHOD (android_hardware_camera, autoFocus, - "(Landroid/hardware/Camera$AutoFocusCallback;)V"); - GST_DVM_GET_METHOD (android_hardware_camera, cancelAutoFocus, "()V"); - GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getCameraInfo, - "(ILandroid/hardware/Camera$CameraInfo;)V"); - GST_DVM_GET_STATIC_METHOD (android_hardware_camera, getNumberOfCameras, - "()I"); - GST_DVM_GET_METHOD (android_hardware_camera, getParameters, - "()Landroid/hardware/Camera$Parameters;"); - GST_DVM_GET_METHOD (android_hardware_camera, lock, "()V"); - GST_DVM_GET_STATIC_METHOD (android_hardware_camera, open, - "(I)Landroid/hardware/Camera;"); - GST_DVM_GET_METHOD (android_hardware_camera, reconnect, "()V"); - GST_DVM_GET_METHOD (android_hardware_camera, release, "()V"); - GST_DVM_GET_METHOD (android_hardware_camera, setErrorCallback, + klass = android_hardware_camera.klass = + gst_amc_jni_get_class (env, &err, "android/hardware/Camera"); + if (!klass) + goto failed; + + android_hardware_camera.addCallbackBuffer = + gst_amc_jni_get_method_id (env, &err, klass, + "addCallbackBuffer", "([B)V"); + + android_hardware_camera.autoFocus = + gst_amc_jni_get_method_id (env, &err, klass, + "autoFocus", "(Landroid/hardware/Camera$AutoFocusCallback;)V"); + + android_hardware_camera.cancelAutoFocus = + gst_amc_jni_get_method_id (env, &err, klass, "cancelAutoFocus", "()V"); + + android_hardware_camera.getCameraInfo = + gst_amc_jni_get_static_method_id (env, &err, klass, + "getCameraInfo", "(ILandroid/hardware/Camera$CameraInfo;)V"); + + android_hardware_camera.getNumberOfCameras = + gst_amc_jni_get_static_method_id (env, &err, klass, + "getNumberOfCameras", "()I"); + + android_hardware_camera.getParameters = + gst_amc_jni_get_method_id (env, &err, klass, + "getParameters", "()Landroid/hardware/Camera$Parameters;"); + + android_hardware_camera.lock = + gst_amc_jni_get_method_id (env, &err, klass, "lock", "()V"); + + android_hardware_camera.open = + gst_amc_jni_get_static_method_id (env, &err, klass, + "open", "(I)Landroid/hardware/Camera;"); + + android_hardware_camera.reconnect = + gst_amc_jni_get_method_id (env, &err, klass, "reconnect", "()V"); + + android_hardware_camera.release = + gst_amc_jni_get_method_id (env, &err, klass, "release", "()V"); + + android_hardware_camera.setErrorCallback = + gst_amc_jni_get_method_id (env, &err, klass, "setErrorCallback", "(Landroid/hardware/Camera$ErrorCallback;)V"); - GST_DVM_GET_METHOD (android_hardware_camera, setParameters, + + android_hardware_camera.setParameters = + gst_amc_jni_get_method_id (env, &err, klass, "setParameters", "(Landroid/hardware/Camera$Parameters;)V"); - GST_DVM_GET_METHOD (android_hardware_camera, setPreviewCallbackWithBuffer, + + android_hardware_camera.setPreviewCallbackWithBuffer = + gst_amc_jni_get_method_id (env, &err, klass, + "setPreviewCallbackWithBuffer", "(Landroid/hardware/Camera$PreviewCallback;)V"); - GST_DVM_GET_METHOD (android_hardware_camera, setPreviewTexture, - "(Landroid/graphics/SurfaceTexture;)V"); - GST_DVM_GET_METHOD (android_hardware_camera, startPreview, "()V"); - GST_DVM_GET_METHOD (android_hardware_camera, startSmoothZoom, "(I)V"); - GST_DVM_GET_METHOD (android_hardware_camera, stopPreview, "()V"); - GST_DVM_GET_METHOD (android_hardware_camera, stopSmoothZoom, "()V"); - GST_DVM_GET_METHOD (android_hardware_camera, unlock, "()V"); + + android_hardware_camera.setPreviewTexture = + gst_amc_jni_get_method_id (env, &err, klass, + "setPreviewTexture", "(Landroid/graphics/SurfaceTexture;)V"); + + android_hardware_camera.startPreview = + gst_amc_jni_get_method_id (env, &err, klass, "startPreview", "()V"); + + android_hardware_camera.startSmoothZoom = + gst_amc_jni_get_method_id (env, &err, klass, "startSmoothZoom", "(I)V"); + + android_hardware_camera.stopPreview = + gst_amc_jni_get_method_id (env, &err, klass, "stopPreview", "()V"); + + android_hardware_camera.stopPreview = + gst_amc_jni_get_method_id (env, &err, klass, "stopPreview", "()V"); + + android_hardware_camera.unlock = + gst_amc_jni_get_method_id (env, &err, klass, "unlock", "()V"); /* android.hardware.Camera.CameraInfo */ - GST_DVM_GET_CLASS (android_hardware_camera_camerainfo, - "android/hardware/Camera$CameraInfo"); - GST_DVM_GET_CONSTRUCTOR (android_hardware_camera_camerainfo, - constructor, "()V"); - GST_DVM_GET_FIELD (android_hardware_camera_camerainfo, facing, "I"); - GST_DVM_GET_FIELD (android_hardware_camera_camerainfo, orientation, "I"); - GST_DVM_GET_CONSTANT (android_hardware_camera_camerainfo, CAMERA_FACING_BACK, - Int, "I"); + klass = android_hardware_camera_camerainfo.klass = + gst_amc_jni_get_class (env, &err, "android/hardware/Camera$CameraInfo"); + if (!klass) + goto failed; + + android_hardware_camera_camerainfo.constructor = + gst_amc_jni_get_method_id (env, &err, klass, "", "()V"); + + android_hardware_camera_camerainfo.facing = + gst_amc_jni_get_field_id (env, &err, klass, "facing", "I"); + + android_hardware_camera_camerainfo.orientation = + gst_amc_jni_get_field_id (env, &err, klass, "orientation", "I"); + + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "CAMERA_FACING_BACK", + "I"); + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_hardware_camera_camerainfo.CAMERA_FACING_BACK)) + goto failed; CameraInfo_CAMERA_FACING_BACK = android_hardware_camera_camerainfo.CAMERA_FACING_BACK; - GST_DVM_GET_CONSTANT (android_hardware_camera_camerainfo, CAMERA_FACING_FRONT, - Int, "I"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "CAMERA_FACING_FRONT", + "I"); + if (!gst_amc_jni_get_static_int_field (env, &err, klass, fieldID, + &android_hardware_camera_camerainfo.CAMERA_FACING_FRONT)) + goto failed; CameraInfo_CAMERA_FACING_FRONT = android_hardware_camera_camerainfo.CAMERA_FACING_FRONT; /* android.hardware.Camera.Size */ - GST_DVM_GET_CLASS (android_hardware_camera_size, - "android/hardware/Camera$Size"); - GST_DVM_GET_FIELD (android_hardware_camera_size, width, "I"); - GST_DVM_GET_FIELD (android_hardware_camera_size, height, "I"); + klass = android_hardware_camera_size.klass = + gst_amc_jni_get_class (env, &err, "android/hardware/Camera$Size"); + if (!klass) + goto failed; + + android_hardware_camera_size.width = + gst_amc_jni_get_field_id (env, &err, klass, "width", "I"); + android_hardware_camera_size.height = + gst_amc_jni_get_field_id (env, &err, klass, "height", "I"); /* android.hardware.Camera.Parameters */ - GST_DVM_GET_CLASS (android_hardware_camera_parameters, - "android/hardware/Camera$Parameters"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, flatten, + klass = android_hardware_camera_parameters.klass = + gst_amc_jni_get_class (env, &err, "android/hardware/Camera$Parameters"); + if (!klass) + goto failed; + + android_hardware_camera_parameters.flatten = + gst_amc_jni_get_method_id (env, &err, klass, "flatten", "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getAntibanding, + + android_hardware_camera_parameters.getAntibanding = + gst_amc_jni_get_method_id (env, &err, klass, "getAntibanding", "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getColorEffect, + + android_hardware_camera_parameters.getColorEffect = + gst_amc_jni_get_method_id (env, &err, klass, "getColorEffect", "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getExposureCompensation, "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getExposureCompensationStep, "()F"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFlashMode, - "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFocalLength, - "()F"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getFocusMode, - "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getHorizontalViewAngle, "()F"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getMaxExposureCompensation, "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getMaxZoom, "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getMinExposureCompensation, "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFormat, + + android_hardware_camera_parameters.getExposureCompensation = + gst_amc_jni_get_method_id (env, &err, klass, "getExposureCompensation", "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewFpsRange, - "([I)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getPreviewSize, - "()Landroid/hardware/Camera$Size;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getSceneMode, + + android_hardware_camera_parameters.getExposureCompensationStep = + gst_amc_jni_get_method_id (env, &err, klass, + "getExposureCompensationStep", "()F"); + + android_hardware_camera_parameters.getFlashMode = + gst_amc_jni_get_method_id (env, &err, klass, "getFlashMode", "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedAntibanding, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedColorEffects, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedFlashModes, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedFocusModes, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedPreviewFormats, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedPreviewFpsRange, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedPreviewSizes, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedSceneModes, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - getSupportedWhiteBalance, "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getVerticalViewAngle, + + android_hardware_camera_parameters.getFocalLength = + gst_amc_jni_get_method_id (env, &err, klass, "getFocalLength", "()F"); + + android_hardware_camera_parameters.getFocusMode = + gst_amc_jni_get_method_id (env, &err, klass, "getFocusMode", + "()Ljava/lang/String;"); + + android_hardware_camera_parameters.getHorizontalViewAngle = + gst_amc_jni_get_method_id (env, &err, klass, "getHorizontalViewAngle", "()F"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getVideoStabilization, - "()Z"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getWhiteBalance, + + android_hardware_camera_parameters.getMaxExposureCompensation = + gst_amc_jni_get_method_id (env, &err, klass, "getMaxExposureCompensation", + "()I"); + + android_hardware_camera_parameters.getMaxZoom = + gst_amc_jni_get_method_id (env, &err, klass, "getMaxZoom", "()I"); + + android_hardware_camera_parameters.getMinExposureCompensation = + gst_amc_jni_get_method_id (env, &err, klass, "getMinExposureCompensation", + "()I"); + + android_hardware_camera_parameters.getPreviewFormat = + gst_amc_jni_get_method_id (env, &err, klass, "getPreviewFormat", "()I"); + + android_hardware_camera_parameters.getPreviewFpsRange = + gst_amc_jni_get_method_id (env, &err, klass, "getPreviewFpsRange", + "([I)V"); + + android_hardware_camera_parameters.getPreviewSize = + gst_amc_jni_get_method_id (env, &err, klass, "getPreviewSize", + "()Landroid/hardware/Camera$Size;"); + + android_hardware_camera_parameters.getSceneMode = + gst_amc_jni_get_method_id (env, &err, klass, "getSceneMode", "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getZoom, "()I"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, getZoomRatios, + + android_hardware_camera_parameters.getSupportedAntibanding = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedAntibanding", "()Ljava/util/List;"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, isSmoothZoomSupported, + + android_hardware_camera_parameters.getSupportedColorEffects = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedColorEffects", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedFlashModes = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedFlashModes", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedFocusModes = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedFocusModes", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedPreviewFormats = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedPreviewFormats", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedPreviewFpsRange = + gst_amc_jni_get_method_id (env, &err, klass, + "getSupportedPreviewFpsRange", "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedPreviewSizes = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedPreviewSizes", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedSceneModes = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedSceneModes", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getSupportedWhiteBalance = + gst_amc_jni_get_method_id (env, &err, klass, "getSupportedWhiteBalance", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.getVerticalViewAngle = + gst_amc_jni_get_method_id (env, &err, klass, "getVerticalViewAngle", + "()F"); + + android_hardware_camera_parameters.getVideoStabilization = + gst_amc_jni_get_method_id (env, &err, klass, "getVideoStabilization", "()Z"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - isVideoStabilizationSupported, "()Z"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, isZoomSupported, + + android_hardware_camera_parameters.getWhiteBalance = + gst_amc_jni_get_method_id (env, &err, klass, "getWhiteBalance", + "()Ljava/lang/String;"); + + android_hardware_camera_parameters.getZoom = + gst_amc_jni_get_method_id (env, &err, klass, "getZoom", "()I"); + + android_hardware_camera_parameters.getZoomRatios = + gst_amc_jni_get_method_id (env, &err, klass, "getZoomRatios", + "()Ljava/util/List;"); + + android_hardware_camera_parameters.isSmoothZoomSupported = + gst_amc_jni_get_method_id (env, &err, klass, "isSmoothZoomSupported", "()Z"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setAntibanding, + + android_hardware_camera_parameters.isVideoStabilizationSupported = + gst_amc_jni_get_method_id (env, &err, klass, + "isVideoStabilizationSupported", "()Z"); + + android_hardware_camera_parameters.isZoomSupported = + gst_amc_jni_get_method_id (env, &err, klass, "isZoomSupported", "()Z"); + + android_hardware_camera_parameters.setAntibanding = + gst_amc_jni_get_method_id (env, &err, klass, "setAntibanding", "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setColorEffect, + + android_hardware_camera_parameters.setColorEffect = + gst_amc_jni_get_method_id (env, &err, klass, "setColorEffect", "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, - setExposureCompensation, "(I)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setFlashMode, - "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setFocusMode, - "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFormat, + + android_hardware_camera_parameters.setExposureCompensation = + gst_amc_jni_get_method_id (env, &err, klass, "setExposureCompensation", "(I)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewFpsRange, - "(II)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setPreviewSize, - "(II)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setSceneMode, + + android_hardware_camera_parameters.setFlashMode = + gst_amc_jni_get_method_id (env, &err, klass, "setFlashMode", "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setWhiteBalance, + + android_hardware_camera_parameters.setFocusMode = + gst_amc_jni_get_method_id (env, &err, klass, "setFocusMode", "(Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setVideoStabilization, + + android_hardware_camera_parameters.setPreviewFormat = + gst_amc_jni_get_method_id (env, &err, klass, "setPreviewFormat", "(I)V"); + + android_hardware_camera_parameters.setPreviewFpsRange = + gst_amc_jni_get_method_id (env, &err, klass, "setPreviewFpsRange", + "(II)V"); + + android_hardware_camera_parameters.setPreviewSize = + gst_amc_jni_get_method_id (env, &err, klass, "setPreviewSize", "(II)V"); + + android_hardware_camera_parameters.setSceneMode = + gst_amc_jni_get_method_id (env, &err, klass, "setSceneMode", + "(Ljava/lang/String;)V"); + + android_hardware_camera_parameters.setWhiteBalance = + gst_amc_jni_get_method_id (env, &err, klass, "setWhiteBalance", + "(Ljava/lang/String;)V"); + + android_hardware_camera_parameters.setVideoStabilization = + gst_amc_jni_get_method_id (env, &err, klass, "setVideoStabilization", "(Z)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, setZoom, "(I)V"); - GST_DVM_GET_METHOD (android_hardware_camera_parameters, unflatten, + + android_hardware_camera_parameters.setZoom = + gst_amc_jni_get_method_id (env, &err, klass, "setZoom", "(I)V"); + + android_hardware_camera_parameters.unflatten = + gst_amc_jni_get_method_id (env, &err, klass, "unflatten", "(Ljava/lang/String;)V"); - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, WHITE_BALANCE_AUTO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "WHITE_BALANCE_AUTO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_AUTO)) + goto failed; + Parameters_WHITE_BALANCE_AUTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_AUTO, NULL); @@ -467,8 +661,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_INCANDESCENT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_INCANDESCENT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT)) + goto failed; + Parameters_WHITE_BALANCE_INCANDESCENT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_INCANDESCENT, NULL); @@ -480,8 +682,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_FLUORESCENT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_FLUORESCENT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT)) + goto failed; + Parameters_WHITE_BALANCE_FLUORESCENT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_FLUORESCENT, NULL); @@ -493,8 +703,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_WARM_FLUORESCENT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_WARM_FLUORESCENT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT)) + goto failed; + Parameters_WHITE_BALANCE_WARM_FLUORESCENT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_WARM_FLUORESCENT, NULL); @@ -506,8 +724,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_DAYLIGHT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_DAYLIGHT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT)) + goto failed; + Parameters_WHITE_BALANCE_DAYLIGHT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_DAYLIGHT, NULL); @@ -518,8 +744,15 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_CLOUDY_DAYLIGHT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_CLOUDY_DAYLIGHT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT)) + goto failed; Parameters_WHITE_BALANCE_CLOUDY_DAYLIGHT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT, NULL); @@ -531,8 +764,15 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - WHITE_BALANCE_TWILIGHT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "WHITE_BALANCE_TWILIGHT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT)) + goto failed; Parameters_WHITE_BALANCE_TWILIGHT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_TWILIGHT, NULL); @@ -543,8 +783,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, WHITE_BALANCE_SHADE, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "WHITE_BALANCE_SHADE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.WHITE_BALANCE_SHADE)) + goto failed; + Parameters_WHITE_BALANCE_SHADE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.WHITE_BALANCE_SHADE, NULL); @@ -555,8 +803,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_NONE, Object, + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_NONE", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_NONE)) + goto failed; + Parameters_EFFECT_NONE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_NONE, NULL); @@ -567,8 +823,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_MONO, Object, + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_MONO", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_MONO)) + goto failed; + Parameters_EFFECT_MONO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_MONO, NULL); @@ -579,8 +843,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_NEGATIVE, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_NEGATIVE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_NEGATIVE)) + goto failed; + Parameters_EFFECT_NEGATIVE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_NEGATIVE, NULL); @@ -591,8 +863,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_SOLARIZE, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_SOLARIZE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_SOLARIZE)) + goto failed; + Parameters_EFFECT_SOLARIZE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_SOLARIZE, NULL); @@ -603,8 +883,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_SEPIA, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_SEPIA", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_SEPIA)) + goto failed; + Parameters_EFFECT_SEPIA = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_SEPIA, NULL); @@ -615,8 +903,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_POSTERIZE, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_POSTERIZE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_POSTERIZE)) + goto failed; + Parameters_EFFECT_POSTERIZE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_POSTERIZE, NULL); @@ -627,8 +923,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_WHITEBOARD, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_WHITEBOARD", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_WHITEBOARD)) + goto failed; + Parameters_EFFECT_WHITEBOARD = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_WHITEBOARD, NULL); @@ -639,8 +943,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_BLACKBOARD, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_BLACKBOARD", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_BLACKBOARD)) + goto failed; + Parameters_EFFECT_BLACKBOARD = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_BLACKBOARD, NULL); @@ -651,8 +963,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, EFFECT_AQUA, Object, + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "EFFECT_AQUA", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.EFFECT_AQUA)) + goto failed; + Parameters_EFFECT_AQUA = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.EFFECT_AQUA, NULL); @@ -663,8 +983,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_AUTO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "ANTIBANDING_AUTO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.ANTIBANDING_AUTO)) + goto failed; + Parameters_ANTIBANDING_AUTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.ANTIBANDING_AUTO, NULL); @@ -675,8 +1003,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_50HZ, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "ANTIBANDING_50HZ", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.ANTIBANDING_50HZ)) + goto failed; + Parameters_ANTIBANDING_50HZ = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.ANTIBANDING_50HZ, NULL); @@ -687,8 +1023,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_60HZ, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "ANTIBANDING_60HZ", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.ANTIBANDING_60HZ)) + goto failed; + Parameters_ANTIBANDING_60HZ = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.ANTIBANDING_60HZ, NULL); @@ -699,8 +1043,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, ANTIBANDING_OFF, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "ANTIBANDING_OFF", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.ANTIBANDING_OFF)) + goto failed; + Parameters_ANTIBANDING_OFF = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.ANTIBANDING_OFF, NULL); @@ -711,8 +1063,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_OFF, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FLASH_MODE_OFF", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FLASH_MODE_OFF)) + goto failed; + Parameters_FLASH_MODE_OFF = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FLASH_MODE_OFF, NULL); @@ -723,8 +1083,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_AUTO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FLASH_MODE_AUTO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FLASH_MODE_AUTO)) + goto failed; + Parameters_FLASH_MODE_AUTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FLASH_MODE_AUTO, NULL); @@ -735,8 +1103,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_ON, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FLASH_MODE_ON", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FLASH_MODE_ON)) + goto failed; + Parameters_FLASH_MODE_ON = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FLASH_MODE_ON, NULL); @@ -747,8 +1123,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_RED_EYE, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FLASH_MODE_RED_EYE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FLASH_MODE_RED_EYE)) + goto failed; + Parameters_FLASH_MODE_RED_EYE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FLASH_MODE_RED_EYE, NULL); @@ -759,8 +1143,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FLASH_MODE_TORCH, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FLASH_MODE_TORCH", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FLASH_MODE_TORCH)) + goto failed; + Parameters_FLASH_MODE_TORCH = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FLASH_MODE_TORCH, NULL); @@ -771,8 +1163,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_AUTO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_AUTO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_AUTO)) + goto failed; + Parameters_SCENE_MODE_AUTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_AUTO, NULL); @@ -783,8 +1183,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_ACTION, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_ACTION", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_ACTION)) + goto failed; + Parameters_SCENE_MODE_ACTION = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_ACTION, NULL); @@ -795,8 +1203,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_PORTRAIT, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_PORTRAIT", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_PORTRAIT)) + goto failed; + Parameters_SCENE_MODE_PORTRAIT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_PORTRAIT, NULL); @@ -807,8 +1223,15 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - SCENE_MODE_LANDSCAPE, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_LANDSCAPE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE)) + goto failed; Parameters_SCENE_MODE_LANDSCAPE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_LANDSCAPE, NULL); @@ -819,8 +1242,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_NIGHT, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_NIGHT", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_NIGHT)) + goto failed; + Parameters_SCENE_MODE_NIGHT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_NIGHT, NULL); @@ -831,8 +1262,15 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - SCENE_MODE_NIGHT_PORTRAIT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "SCENE_MODE_NIGHT_PORTRAIT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT)) + goto failed; Parameters_SCENE_MODE_NIGHT_PORTRAIT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_NIGHT_PORTRAIT, NULL); @@ -844,8 +1282,15 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_THEATRE, - Object, "Ljava/lang/String;"); + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_THEATRE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_THEATRE)) + goto failed; + Parameters_SCENE_MODE_THEATRE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_THEATRE, NULL); @@ -856,8 +1301,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_BEACH, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_BEACH", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_BEACH)) + goto failed; + Parameters_SCENE_MODE_BEACH = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_BEACH, NULL); @@ -868,8 +1321,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SNOW, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_SNOW", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_SNOW)) + goto failed; + Parameters_SCENE_MODE_SNOW = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_SNOW, NULL); @@ -880,8 +1341,17 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SUNSET, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_SUNSET", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_SUNSET)) + goto failed; + + Parameters_SCENE_MODE_SUNSET = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_SUNSET, NULL); @@ -892,8 +1362,17 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - SCENE_MODE_STEADYPHOTO, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "SCENE_MODE_STEADYPHOTO", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO)) + goto failed; + + Parameters_SCENE_MODE_STEADYPHOTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_STEADYPHOTO, NULL); @@ -904,8 +1383,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - SCENE_MODE_FIREWORKS, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_FIREWORKS", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_FIREWORKS)) + goto failed; + Parameters_SCENE_MODE_FIREWORKS = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_FIREWORKS, NULL); @@ -916,8 +1403,17 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_SPORTS, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_SPORTS", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_SPORTS)) + goto failed; + + Parameters_SCENE_MODE_SPORTS = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_SPORTS, NULL); @@ -928,8 +1424,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_PARTY, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_PARTY", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_PARTY)) + goto failed; + Parameters_SCENE_MODE_PARTY = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_PARTY, NULL); @@ -940,8 +1444,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - SCENE_MODE_CANDLELIGHT, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "SCENE_MODE_CANDLELIGHT", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT)) + goto failed; + Parameters_SCENE_MODE_CANDLELIGHT = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_CANDLELIGHT, NULL); @@ -952,8 +1464,17 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, SCENE_MODE_BARCODE, - Object, "Ljava/lang/String;"); + + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "SCENE_MODE_BARCODE", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.SCENE_MODE_BARCODE)) + goto failed; + Parameters_SCENE_MODE_BARCODE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.SCENE_MODE_BARCODE, NULL); @@ -964,8 +1485,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_AUTO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FOCUS_MODE_AUTO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_AUTO)) + goto failed; + Parameters_FOCUS_MODE_AUTO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_AUTO, NULL); @@ -976,8 +1505,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_INFINITY, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FOCUS_MODE_INFINITY", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_INFINITY)) + goto failed; + Parameters_FOCUS_MODE_INFINITY = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_INFINITY, NULL); @@ -988,8 +1525,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_MACRO, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FOCUS_MODE_MACRO", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_MACRO)) + goto failed; + Parameters_FOCUS_MODE_MACRO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_MACRO, NULL); @@ -1000,8 +1545,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_FIXED, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FOCUS_MODE_FIXED", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_FIXED)) + goto failed; + Parameters_FOCUS_MODE_FIXED = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_FIXED, NULL); @@ -1012,8 +1565,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, FOCUS_MODE_EDOF, - Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, "FOCUS_MODE_EDOF", + "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_EDOF)) + goto failed; + Parameters_FOCUS_MODE_EDOF = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_EDOF, NULL); @@ -1024,8 +1585,16 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - FOCUS_MODE_CONTINUOUS_VIDEO, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "FOCUS_MODE_CONTINUOUS_VIDEO", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) + goto failed; + Parameters_FOCUS_MODE_CONTINUOUS_VIDEO = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_VIDEO, NULL); @@ -1037,8 +1606,17 @@ _init_classes (void) (*env)->NewGlobalRef (env, local); (*env)->DeleteLocalRef (env, local); } - GST_DVM_GET_CONSTANT (android_hardware_camera_parameters, - FOCUS_MODE_CONTINUOUS_PICTURE, Object, "Ljava/lang/String;"); + + fieldID = + gst_amc_jni_get_static_field_id (env, &err, klass, + "FOCUS_MODE_CONTINUOUS_PICTURE", "Ljava/lang/String;"); + if (!fieldID) + goto failed; + if (!gst_amc_jni_get_static_object_field (env, &err, klass, fieldID, + &android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) + goto failed; + + Parameters_FOCUS_MODE_CONTINUOUS_PICTURE = (*env)->GetStringUTFChars (env, android_hardware_camera_parameters.FOCUS_MODE_CONTINUOUS_PICTURE, NULL); @@ -1052,137 +1630,65 @@ _init_classes (void) } /* java.lang.String */ - GST_DVM_GET_CLASS (java_lang_string, "java/lang/String"); - GST_DVM_GET_METHOD (java_lang_string, equals, "(Ljava/lang/Object;)Z"); + klass = java_lang_string.klass = + gst_amc_jni_get_class (env, &err, "java/lang/String"); + java_lang_string.equals = + gst_amc_jni_get_method_id (env, &err, klass, "equals", + "(Ljava/lang/Object;)Z"); /* java.util.List */ - GST_DVM_GET_CLASS (java_util_list, "java/util/List"); - GST_DVM_GET_METHOD (java_util_list, iterator, "()Ljava/util/Iterator;"); + klass = java_util_list.klass = + gst_amc_jni_get_class (env, &err, "java/util/List"); + java_util_list.iterator = + gst_amc_jni_get_method_id (env, &err, klass, "iterator", + "()Ljava/util/Iterator;"); /* java.util.Iterator */ - GST_DVM_GET_CLASS (java_util_iterator, "java/util/Iterator"); - GST_DVM_GET_METHOD (java_util_iterator, hasNext, "()Z"); - GST_DVM_GET_METHOD (java_util_iterator, next, "()Ljava/lang/Object;"); + klass = java_util_iterator.klass = + gst_amc_jni_get_class (env, &err, "java/util/Iterator"); + java_util_iterator.hasNext = + gst_amc_jni_get_method_id (env, &err, klass, "hasNext", "()Z"); + java_util_iterator.next = + gst_amc_jni_get_method_id (env, &err, klass, "next", + "()Ljava/lang/Object;"); /* java.lang.Integer */ - GST_DVM_GET_CLASS (java_lang_integer, "java/lang/Integer"); - GST_DVM_GET_METHOD (java_lang_integer, intValue, "()I"); + klass = java_lang_integer.klass = + gst_amc_jni_get_class (env, &err, "java/lang/Integer"); + java_lang_integer.intValue = + gst_amc_jni_get_method_id (env, &err, klass, "intValue", "()I"); - /* com.gstreamer.GstAhcCallback */ - if (gst_ahc_callback_jar && g_getenv ("TMP")) { - jclass dex_loader = NULL; - gchar *path = g_strdup_printf ("%s/GstAhcCallback.jar", g_getenv ("TMP")); - FILE *fd = fopen (path, "wb"); - - GST_DEBUG ("Found embedded GstAhcCallback.jar, trying to load dynamically" - "from %s", path); - if (fd) { - if (fwrite (gst_ahc_callback_jar, gst_ahc_callback_jar_size, 1, fd) == 1) { - dex_loader = (*env)->FindClass (env, "dalvik/system/DexClassLoader"); - (*env)->ExceptionClear (env); - } - fclose (fd); - } - - if (dex_loader) { - jmethodID constructor; - jmethodID load_class; - - constructor = (*env)->GetMethodID (env, dex_loader, "", - "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" - "Ljava/lang/ClassLoader;)V"); - load_class = (*env)->GetMethodID (env, dex_loader, "loadClass", - "(Ljava/lang/String;)Ljava/lang/Class;"); - (*env)->ExceptionClear (env); - if (constructor && load_class) { - jstring dex_path = NULL; - jstring optimized_directory = NULL; - - dex_path = (*env)->NewStringUTF (env, path); - if (g_getenv ("DEX")) - optimized_directory = (*env)->NewStringUTF (env, g_getenv ("DEX")); - else - optimized_directory = (*env)->NewStringUTF (env, g_getenv ("TMP")); - (*env)->ExceptionClear (env); - if (dex_path && optimized_directory) { - jobject loader; - jobject parent = NULL; - jclass klass; - - klass = (*env)->FindClass (env, "java/lang/Class"); - (*env)->ExceptionClear (env); - if (klass) { - jmethodID get_class_loader; - - get_class_loader = (*env)->GetMethodID (env, klass, - "getClassLoader", "()Ljava/lang/ClassLoader;"); - (*env)->ExceptionClear (env); - if (get_class_loader) { - parent = (*env)->CallObjectMethod (env, klass, get_class_loader); - (*env)->ExceptionClear (env); - } - (*env)->DeleteLocalRef (env, klass); - } - loader = (*env)->NewObject (env, dex_loader, constructor, dex_path, - optimized_directory, NULL, parent); - (*env)->ExceptionClear (env); - if (loader) { - jstring class_name = NULL; - - class_name = (*env)->NewStringUTF (env, - "com/gstreamer/GstAhcCallback"); - (*env)->ExceptionClear (env); - if (class_name) { - jclass temp; - - temp = (*env)->CallObjectMethod (env, loader, load_class, - class_name); - (*env)->ExceptionClear (env); - if (temp) { - - GST_DEBUG ("Successfully loaded embedded GstAhcCallback"); - com_gstreamer_gstahccallback.klass = (*env)->NewGlobalRef (env, - temp); - (*env)->DeleteLocalRef (env, temp); - } - (*env)->DeleteLocalRef (env, class_name); - } - (*env)->DeleteLocalRef (env, loader); - } - if (parent) - (*env)->DeleteLocalRef (env, parent); - } - if (dex_path) - (*env)->DeleteLocalRef (env, dex_path); - if (optimized_directory) - (*env)->DeleteLocalRef (env, optimized_directory); - } - (*env)->DeleteLocalRef (env, dex_loader); - g_free (path); - } - } else { - GST_WARNING ("Did not find embedded GstAhcCallback.jar, fallback to" - " FindClass"); + if (!org_freedesktop_gstreamer_androidmedia_gstahccallback.klass) { + org_freedesktop_gstreamer_androidmedia_gstahccallback.klass = + gst_amc_jni_get_class (env, &err, "org/freedesktop/gstreamer/androidmedia/GstAhcCallback"); } - if (!com_gstreamer_gstahccallback.klass) { - GST_DVM_GET_CLASS (com_gstreamer_gstahccallback, - "com/gstreamer/GstAhcCallback"); - } - GST_DVM_GET_CONSTRUCTOR (com_gstreamer_gstahccallback, constructor, "(JJ)V"); + org_freedesktop_gstreamer_androidmedia_gstahccallback.constructor = + gst_amc_jni_get_method_id (env, &err, org_freedesktop_gstreamer_androidmedia_gstahccallback.klass, + "", "(JJ)V"); - if ((*env)->RegisterNatives (env, com_gstreamer_gstahccallback.klass, + if ((*env)->RegisterNatives (env, org_freedesktop_gstreamer_androidmedia_gstahccallback.klass, native_methods, G_N_ELEMENTS (native_methods))) { GST_ERROR ("Failed to register native methods for GstAhcCallback"); return FALSE; } return TRUE; + +failed: + if (err) { + GST_ERROR ("Failed to get android.hardware.Camera class: %s", err->message); + g_clear_error (&err); + } + + return FALSE; + } gboolean gst_android_hardware_camera_init (void) { + GST_DEBUG_CATEGORY_INIT (ahc_debug, "ahc", 0, "Android Gstreamer Hardware Camera"); if (!_init_classes ()) { gst_android_hardware_camera_deinit (); return FALSE; @@ -1194,7 +1700,7 @@ gst_android_hardware_camera_init (void) void gst_android_hardware_camera_deinit (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); if (android_hardware_camera.klass) (*env)->DeleteGlobalRef (env, android_hardware_camera.klass); @@ -1666,11 +2172,11 @@ gst_android_hardware_camera_deinit (void) (*env)->DeleteGlobalRef (env, java_lang_integer.klass); java_lang_integer.klass = NULL; - if (com_gstreamer_gstahccallback.klass) { - (*env)->UnregisterNatives (env, com_gstreamer_gstahccallback.klass); - (*env)->DeleteGlobalRef (env, com_gstreamer_gstahccallback.klass); + if (org_freedesktop_gstreamer_androidmedia_gstahccallback.klass) { + (*env)->UnregisterNatives (env, org_freedesktop_gstreamer_androidmedia_gstahccallback.klass); + (*env)->DeleteGlobalRef (env, org_freedesktop_gstreamer_androidmedia_gstahccallback.klass); } - com_gstreamer_gstahccallback.klass = NULL; + org_freedesktop_gstreamer_androidmedia_gstahccallback.klass = NULL; } /* android.hardware.Camera */ @@ -1684,7 +2190,9 @@ gst_android_hardware_camera_deinit (void) void gst_ah_camera_add_callback_buffer (GstAHCamera * self, jbyteArray buffer) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); + + GST_DEBUG ("add callback_buffer %p", buffer); AHC_CALL (, Void, addCallbackBuffer, buffer); } @@ -1693,14 +2201,14 @@ gboolean gst_ah_camera_auto_focus (GstAHCamera * self, GstAHCAutoFocusCallback cb, gpointer user_data) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; gboolean ret = FALSE; if (cb) { object = (*env)->NewObject (env, - com_gstreamer_gstahccallback.klass, - com_gstreamer_gstahccallback.constructor, + org_freedesktop_gstreamer_androidmedia_gstahccallback.klass, + org_freedesktop_gstreamer_androidmedia_gstahccallback.constructor, *((jlong *) & cb), *((jlong *) & user_data)); if (!object) { GST_ERROR ("Failed to create callback object"); @@ -1722,7 +2230,7 @@ done: gboolean gst_ah_camera_cancel_auto_focus (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, cancelAutoFocus); @@ -1732,7 +2240,7 @@ gst_ah_camera_cancel_auto_focus (GstAHCamera * self) gboolean gst_ah_camera_get_camera_info (gint camera_id, GstAHCCameraInfo * camera_info) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject jcamera_info = NULL; gboolean ret = FALSE; @@ -1774,7 +2282,7 @@ done: gint gst_ah_camera_get_number_of_cameras (void) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint num_cameras; num_cameras = AHC_STATIC_CALL (return -1, Int, getNumberOfCameras); @@ -1785,7 +2293,7 @@ gst_ah_camera_get_number_of_cameras (void) GstAHCParameters * gst_ah_camera_get_parameters (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; GstAHCParameters *params = NULL; @@ -1802,13 +2310,15 @@ gst_ah_camera_get_parameters (GstAHCamera * self) } } + GST_DEBUG ("return parameters %p", params->object); + return params; } gboolean gst_ah_camera_lock (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, lock); @@ -1818,7 +2328,7 @@ gst_ah_camera_lock (GstAHCamera * self) GstAHCamera * gst_ah_camera_open (gint camera_id) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; GstAHCamera *camera = NULL; @@ -1842,7 +2352,7 @@ done: gboolean gst_ah_camera_reconnect (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, reconnect); @@ -1852,15 +2362,15 @@ gst_ah_camera_reconnect (GstAHCamera * self) void gst_ah_camera_release (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (, Void, release); } void -gst_ah_camera_release (GstAHCamera * self) +gst_ah_camera_free (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAHCamera, self); @@ -1870,7 +2380,7 @@ gst_ah_camera_release (GstAHCamera * self) gboolean gst_ah_camera_set_parameters (GstAHCamera * self, GstAHCParameters * params) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, setParameters, params->object); @@ -1881,14 +2391,14 @@ gboolean gst_ah_camera_set_error_callback (GstAHCamera * self, GstAHCErrorCallback cb, gpointer user_data) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; gboolean ret = FALSE; if (cb) { object = (*env)->NewObject (env, - com_gstreamer_gstahccallback.klass, - com_gstreamer_gstahccallback.constructor, + org_freedesktop_gstreamer_androidmedia_gstahccallback.klass, + org_freedesktop_gstreamer_androidmedia_gstahccallback.constructor, *((jlong *) & cb), *((jlong *) & user_data)); if (!object) { GST_ERROR ("Failed to create callback object"); @@ -1911,14 +2421,14 @@ gboolean gst_ah_camera_set_preview_callback_with_buffer (GstAHCamera * self, GstAHCPreviewCallback cb, gpointer user_data) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject object = NULL; gboolean ret = FALSE; if (cb) { object = (*env)->NewObject (env, - com_gstreamer_gstahccallback.klass, - com_gstreamer_gstahccallback.constructor, + org_freedesktop_gstreamer_androidmedia_gstahccallback.klass, + org_freedesktop_gstreamer_androidmedia_gstahccallback.constructor, *((jlong *) & cb), *((jlong *) & user_data)); if (!object) { GST_ERROR ("Failed to create callback object"); @@ -1941,7 +2451,7 @@ void gst_ah_camera_set_preview_texture (GstAHCamera * self, GstAGSurfaceTexture * surfaceTexture) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (, Void, setPreviewTexture, surfaceTexture->object); } @@ -1949,7 +2459,7 @@ gst_ah_camera_set_preview_texture (GstAHCamera * self, gboolean gst_ah_camera_start_preview (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, startPreview); @@ -1959,7 +2469,7 @@ gst_ah_camera_start_preview (GstAHCamera * self) gboolean gst_ah_camera_start_smooth_zoom (GstAHCamera * self, gint value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, startSmoothZoom, value); @@ -1969,7 +2479,7 @@ gst_ah_camera_start_smooth_zoom (GstAHCamera * self, gint value) gboolean gst_ah_camera_stop_preview (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, stopPreview); @@ -1979,7 +2489,7 @@ gst_ah_camera_stop_preview (GstAHCamera * self) gboolean gst_ah_camera_stop_smooth_zoom (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, stopSmoothZoom); @@ -1989,7 +2499,7 @@ gst_ah_camera_stop_smooth_zoom (GstAHCamera * self) gboolean gst_ah_camera_unlock (GstAHCamera * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHC_CALL (return FALSE, Void, unlock); @@ -2051,10 +2561,12 @@ java_lang_integer_int_value (JNIEnv * env, jobject obj) return (*env)->CallIntMethod (env, obj, java_lang_integer.intValue); } + /* android.hardware.Camera.Parameters */ #define AHCP_CALL(error_statement, type, method, ...) \ GST_DVM_CALL (error_statement, self->object, type, \ android_hardware_camera_parameters, method, ## __VA_ARGS__); + #define AHCP_STATIC_CALL(error_statement, type, method, ...) \ GST_DVM_STATIC_CALL (error_statement, type, \ android_hardware_camera_parameters, method, ## __VA_ARGS__); @@ -2428,7 +2940,7 @@ _focus_mode_to_jstring (const gchar * focus_mode) gchar * gst_ahc_parameters_flatten (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring v_str = NULL; const gchar *v = NULL; gchar *ret = NULL; @@ -2454,7 +2966,7 @@ done: const gchar * gst_ahc_parameters_get_antibanding (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring antibanding; @@ -2471,7 +2983,7 @@ gst_ahc_parameters_get_antibanding (GstAHCParameters * self) const gchar * gst_ahc_parameters_get_color_effect (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring color_effect; @@ -2488,7 +3000,7 @@ gst_ahc_parameters_get_color_effect (GstAHCParameters * self) gint gst_ahc_parameters_get_exposure_compensation (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint ev; ev = AHCP_CALL (return -1, Int, getExposureCompensation); @@ -2499,7 +3011,7 @@ gst_ahc_parameters_get_exposure_compensation (GstAHCParameters * self) gfloat gst_ahc_parameters_get_exposure_compensation_step (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gfloat step; step = AHCP_CALL (return 0.0, Float, getExposureCompensationStep); @@ -2510,7 +3022,7 @@ gst_ahc_parameters_get_exposure_compensation_step (GstAHCParameters * self) const gchar * gst_ahc_parameters_get_flash_mode (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring flash_mode; @@ -2527,7 +3039,7 @@ gst_ahc_parameters_get_flash_mode (GstAHCParameters * self) gfloat gst_ahc_parameters_get_focal_length (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gfloat length; length = AHCP_CALL (return 0.0, Float, getFocalLength); @@ -2538,7 +3050,7 @@ gst_ahc_parameters_get_focal_length (GstAHCParameters * self) const gchar * gst_ahc_parameters_get_focus_mode (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring focus_mode; @@ -2555,7 +3067,7 @@ gst_ahc_parameters_get_focus_mode (GstAHCParameters * self) gfloat gst_ahc_parameters_get_horizontal_view_angle (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gfloat angle; angle = AHCP_CALL (return 0.0, Float, getHorizontalViewAngle); @@ -2566,7 +3078,7 @@ gst_ahc_parameters_get_horizontal_view_angle (GstAHCParameters * self) gint gst_ahc_parameters_get_max_exposure_compensation (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint max; max = AHCP_CALL (return 0, Int, getMaxExposureCompensation); @@ -2577,7 +3089,7 @@ gst_ahc_parameters_get_max_exposure_compensation (GstAHCParameters * self) gint gst_ahc_parameters_get_max_zoom (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint max; max = AHCP_CALL (return -1, Int, getMaxZoom); @@ -2588,7 +3100,7 @@ gst_ahc_parameters_get_max_zoom (GstAHCParameters * self) gint gst_ahc_parameters_get_min_exposure_compensation (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint min; min = AHCP_CALL (return 0, Int, getMinExposureCompensation); @@ -2599,7 +3111,7 @@ gst_ahc_parameters_get_min_exposure_compensation (GstAHCParameters * self) gint gst_ahc_parameters_get_preview_format (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint format; format = AHCP_CALL (return 0, Int, getPreviewFormat); @@ -2611,7 +3123,7 @@ gboolean gst_ahc_parameters_get_preview_fps_range (GstAHCParameters * self, gint * min, gint * max) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gboolean ret = FALSE; jintArray range = NULL; jint *fps = NULL; @@ -2649,7 +3161,7 @@ done: GstAHCSize * gst_ahc_parameters_get_preview_size (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject jsize = NULL; GstAHCSize *size = NULL; @@ -2687,7 +3199,7 @@ done: const gchar * gst_ahc_parameters_get_scene_mode (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring scene_mode; @@ -2704,7 +3216,7 @@ gst_ahc_parameters_get_scene_mode (GstAHCParameters * self) GList * gst_ahc_parameters_get_supported_antibanding (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2742,7 +3254,7 @@ gst_ahc_parameters_supported_antibanding_free (GList * list) GList * gst_ahc_parameters_get_supported_color_effects (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2780,7 +3292,7 @@ gst_ahc_parameters_supported_color_effects_free (GList * list) GList * gst_ahc_parameters_get_supported_flash_modes (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2818,7 +3330,7 @@ gst_ahc_parameters_supported_flash_modes_free (GList * list) GList * gst_ahc_parameters_get_supported_focus_modes (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2856,7 +3368,7 @@ gst_ahc_parameters_supported_focus_modes_free (GList * list) GList * gst_ahc_parameters_get_supported_preview_formats (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2894,7 +3406,7 @@ gst_ahc_parameters_supported_preview_formats_free (GList * list) GList * gst_ahc_parameters_get_supported_preview_fps_range (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2934,7 +3446,7 @@ gst_ahc_parameters_supported_preview_fps_range_free (GList * list) GList * gst_ahc_parameters_get_supported_preview_sizes (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -2978,7 +3490,7 @@ gst_ahc_parameters_supported_preview_sizes_free (GList * list) GList * gst_ahc_parameters_get_supported_scene_modes (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -3016,7 +3528,7 @@ gst_ahc_parameters_supported_scene_modes_free (GList * list) GList * gst_ahc_parameters_get_supported_white_balance (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -3054,7 +3566,7 @@ gst_ahc_parameters_supported_white_balance_free (GList * list) gfloat gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gfloat angle; angle = AHCP_CALL (return 0.0, Float, getVerticalViewAngle); @@ -3065,7 +3577,7 @@ gst_ahc_parameters_get_vertical_view_angle (GstAHCParameters * self) gboolean gst_ahc_parameters_get_video_stabilization (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gboolean ret; ret = AHCP_CALL (return FALSE, Boolean, getVideoStabilization); @@ -3076,7 +3588,7 @@ gst_ahc_parameters_get_video_stabilization (GstAHCParameters * self) const gchar * gst_ahc_parameters_get_white_balance (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); const gchar *ret = NULL; jstring white_balance; @@ -3093,7 +3605,7 @@ gst_ahc_parameters_get_white_balance (GstAHCParameters * self) gint gst_ahc_parameters_get_zoom (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint zoom; zoom = AHCP_CALL (return -1, Int, getZoom); @@ -3104,7 +3616,7 @@ gst_ahc_parameters_get_zoom (GstAHCParameters * self) GList * gst_ahc_parameters_get_zoom_ratios (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jobject list = NULL; GList *ret = NULL; @@ -3142,7 +3654,7 @@ gst_ahc_parameters_zoom_ratios_free (GList * list) gboolean gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gboolean supported; supported = AHCP_CALL (return FALSE, Boolean, isSmoothZoomSupported); @@ -3153,7 +3665,7 @@ gst_ahc_parameters_is_smooth_zoom_supported (GstAHCParameters * self) gboolean gst_ahc_parameters_is_video_stabilization_supported (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gboolean supported; supported = AHCP_CALL (return FALSE, Boolean, isVideoStabilizationSupported); @@ -3164,7 +3676,7 @@ gst_ahc_parameters_is_video_stabilization_supported (GstAHCParameters * self) gboolean gst_ahc_parameters_is_zoom_supported (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gboolean supported; supported = AHCP_CALL (return FALSE, Boolean, isZoomSupported); @@ -3176,7 +3688,7 @@ gboolean gst_ahc_parameters_set_antibanding (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring antibanding; antibanding = _antibanding_to_jstring (value); @@ -3192,7 +3704,7 @@ gboolean gst_ahc_parameters_set_color_effect (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring color_effect; color_effect = _color_effect_to_jstring (value); @@ -3208,7 +3720,7 @@ gboolean gst_ahc_parameters_set_exposure_compensation (GstAHCParameters * self, gint value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setExposureCompensation, value); @@ -3218,7 +3730,7 @@ gst_ahc_parameters_set_exposure_compensation (GstAHCParameters * self, gboolean gst_ahc_parameters_set_flash_mode (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring flash_mode; flash_mode = _flash_mode_to_jstring (value); @@ -3233,7 +3745,7 @@ gst_ahc_parameters_set_flash_mode (GstAHCParameters * self, const gchar * value) gboolean gst_ahc_parameters_set_focus_mode (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring focus_mode; focus_mode = _focus_mode_to_jstring (value); @@ -3248,7 +3760,7 @@ gst_ahc_parameters_set_focus_mode (GstAHCParameters * self, const gchar * value) gboolean gst_ahc_parameters_set_preview_format (GstAHCParameters * self, gint format) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setPreviewFormat, format); @@ -3259,7 +3771,7 @@ gboolean gst_ahc_parameters_set_preview_fps_range (GstAHCParameters * self, gint min, gint max) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setPreviewFpsRange, min, max); @@ -3270,7 +3782,7 @@ gboolean gst_ahc_parameters_set_preview_size (GstAHCParameters * self, gint width, gint height) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setPreviewSize, width, height); @@ -3280,7 +3792,7 @@ gst_ahc_parameters_set_preview_size (GstAHCParameters * self, gboolean gst_ahc_parameters_set_scene_mode (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring scene_mode; scene_mode = _scene_mode_to_jstring (value); @@ -3297,7 +3809,7 @@ gboolean gst_ahc_parameters_set_video_stabilization (GstAHCParameters * self, gboolean toggle) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setVideoStabilization, toggle); @@ -3308,7 +3820,7 @@ gboolean gst_ahc_parameters_set_white_balance (GstAHCParameters * self, const gchar * value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring white_balance; white_balance = _white_balance_to_jstring (value); @@ -3323,7 +3835,7 @@ gst_ahc_parameters_set_white_balance (GstAHCParameters * self, gboolean gst_ahc_parameters_set_zoom (GstAHCParameters * self, gint value) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); AHCP_CALL (return FALSE, Void, setZoom, value); @@ -3333,7 +3845,7 @@ gst_ahc_parameters_set_zoom (GstAHCParameters * self, gint value) gboolean gst_ahc_parameters_unflatten (GstAHCParameters * self, const gchar * flattened) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); jstring v_str = NULL; gboolean ret = TRUE; @@ -3351,7 +3863,12 @@ gst_ahc_parameters_unflatten (GstAHCParameters * self, const gchar * flattened) void gst_ahc_parameters_free (GstAHCParameters * self) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); + + g_return_if_fail (self != NULL); + g_return_if_fail (self->object != NULL); + + GST_DEBUG ("freeing parameters %p", self->object); (*env)->DeleteGlobalRef (env, self->object); g_slice_free (GstAHCParameters, self); diff --git a/sys/androidmedia/gst-android-hardware-camera.h b/sys/androidmedia/gst-android-hardware-camera.h index 03db671df4..44e7842657 100644 --- a/sys/androidmedia/gst-android-hardware-camera.h +++ b/sys/androidmedia/gst-android-hardware-camera.h @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation diff --git a/sys/androidmedia/gst-android-media-mediacodec.c b/sys/androidmedia/gst-android-media-mediacodec.c deleted file mode 100644 index c676efd752..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodec.c +++ /dev/null @@ -1,531 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include - -#include "gst-android-media-mediacodec.h" - - -static struct -{ - jclass klass; - jmethodID constructor; - jfieldID flags; - jfieldID offset; - jfieldID presentationTimeUs; - jfieldID size; -} android_media_mediacodec_bufferinfo; - -static struct -{ - jclass klass; - jmethodID configure; - jmethodID createByCodecName; - jmethodID createDecoderByType; - jmethodID createEncoderByType; - jmethodID dequeueInputBuffer; - jmethodID dequeueOutputBuffer; - jmethodID flush; - jmethodID getInputBuffers; - jmethodID getOutputBuffers; - jmethodID getOutputFormat; - jmethodID queueInputBuffer; - jmethodID release; - jmethodID releaseOutputBuffer; - jmethodID start; - jmethodID stop; - jint BUFFER_FLAG_SYNC_FRAME; - jint BUFFER_FLAG_CODEC_CONFIG; - jint BUFFER_FLAG_END_OF_STREAM; - jint CONFIGURE_FLAG_ENCODE; - jint INFO_TRY_AGAIN_LATER; - jint INFO_OUTPUT_FORMAT_CHANGED; - jint INFO_OUTPUT_BUFFERS_CHANGED; -} android_media_mediacodec; - -gint MediaCodec_BUFFER_FLAG_SYNC_FRAME; -gint MediaCodec_BUFFER_FLAG_CODEC_CONFIG; -gint MediaCodec_BUFFER_FLAG_END_OF_STREAM; - -gint MediaCodec_CONFIGURE_FLAG_ENCODE; - -gint MediaCodec_INFO_TRY_AGAIN_LATER; -gint MediaCodec_INFO_OUTPUT_FORMAT_CHANGED; -gint MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED; - -static gboolean -_init_classes (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - /* android.media.MediaCodec */ - GST_DVM_GET_CLASS (android_media_mediacodec, "android/media/MediaCodec"); - GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createByCodecName, - "(Ljava/lang/String;)Landroid/media/MediaCodec;"); - GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createDecoderByType, - "(Ljava/lang/String;)Landroid/media/MediaCodec;"); - GST_DVM_GET_STATIC_METHOD (android_media_mediacodec, createEncoderByType, - "(Ljava/lang/String;)Landroid/media/MediaCodec;"); - GST_DVM_GET_METHOD (android_media_mediacodec, configure, - "(Landroid/media/MediaFormat;Landroid/view/Surface;" - "Landroid/media/MediaCrypto;I)V"); - GST_DVM_GET_METHOD (android_media_mediacodec, dequeueInputBuffer, "(J)I"); - GST_DVM_GET_METHOD (android_media_mediacodec, dequeueOutputBuffer, - "(Landroid/media/MediaCodec$BufferInfo;J)I"); - GST_DVM_GET_METHOD (android_media_mediacodec, flush, "()V"); - GST_DVM_GET_METHOD (android_media_mediacodec, getInputBuffers, - "()[Ljava/nio/ByteBuffer;"); - GST_DVM_GET_METHOD (android_media_mediacodec, getOutputBuffers, - "()[Ljava/nio/ByteBuffer;"); - GST_DVM_GET_METHOD (android_media_mediacodec, getOutputFormat, - "()Landroid/media/MediaFormat;"); - GST_DVM_GET_METHOD (android_media_mediacodec, queueInputBuffer, "(IIIJI)V"); - GST_DVM_GET_METHOD (android_media_mediacodec, release, "()V"); - GST_DVM_GET_METHOD (android_media_mediacodec, releaseOutputBuffer, "(IZ)V"); - GST_DVM_GET_METHOD (android_media_mediacodec, start, "()V"); - GST_DVM_GET_METHOD (android_media_mediacodec, stop, "()V"); - - - GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_SYNC_FRAME, Int, - "I"); - MediaCodec_BUFFER_FLAG_SYNC_FRAME = - android_media_mediacodec.BUFFER_FLAG_SYNC_FRAME; - GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_CODEC_CONFIG, Int, - "I"); - MediaCodec_BUFFER_FLAG_CODEC_CONFIG = - android_media_mediacodec.BUFFER_FLAG_CODEC_CONFIG; - GST_DVM_GET_CONSTANT (android_media_mediacodec, BUFFER_FLAG_END_OF_STREAM, - Int, "I"); - MediaCodec_BUFFER_FLAG_END_OF_STREAM = - android_media_mediacodec.BUFFER_FLAG_END_OF_STREAM; - - GST_DVM_GET_CONSTANT (android_media_mediacodec, CONFIGURE_FLAG_ENCODE, Int, - "I"); - MediaCodec_CONFIGURE_FLAG_ENCODE = - android_media_mediacodec.CONFIGURE_FLAG_ENCODE; - - GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_TRY_AGAIN_LATER, Int, - "I"); - MediaCodec_INFO_TRY_AGAIN_LATER = - android_media_mediacodec.INFO_TRY_AGAIN_LATER; - GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_OUTPUT_FORMAT_CHANGED, - Int, "I"); - MediaCodec_INFO_OUTPUT_FORMAT_CHANGED = - android_media_mediacodec.INFO_OUTPUT_FORMAT_CHANGED; - GST_DVM_GET_CONSTANT (android_media_mediacodec, INFO_OUTPUT_BUFFERS_CHANGED, - Int, "I"); - MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED = - android_media_mediacodec.INFO_OUTPUT_BUFFERS_CHANGED; - - /* android.media.MediaCodec.BufferInfo */ - GST_DVM_GET_CLASS (android_media_mediacodec_bufferinfo, - "android/media/MediaCodec$BufferInfo"); - GST_DVM_GET_CONSTRUCTOR (android_media_mediacodec_bufferinfo, constructor, - "()V"); - GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, flags, "I"); - GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, offset, "I"); - GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, presentationTimeUs, - "J"); - GST_DVM_GET_FIELD (android_media_mediacodec_bufferinfo, size, "I"); - - return TRUE; -} - -gboolean -gst_android_media_mediacodec_init (void) -{ - if (!_init_classes ()) { - gst_android_media_mediacodec_deinit (); - return FALSE; - } - - return TRUE; -} - -void -gst_android_media_mediacodec_deinit (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - if (android_media_mediacodec.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodec.klass); - android_media_mediacodec.klass = NULL; - - if (android_media_mediacodec_bufferinfo.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodec_bufferinfo.klass); - android_media_mediacodec_bufferinfo.klass = NULL; -} - -/* android.media.MediaCodec */ - -#define AMMC_CALL(error_statement, type, method, ...) \ - GST_DVM_CALL (error_statement, self->object, type, \ - android_media_mediacodec, method, ## __VA_ARGS__); -#define AMMC_STATIC_CALL(error_statement, type, method, ...) \ - GST_DVM_STATIC_CALL (error_statement, type, \ - android_media_mediacodec, method, ## __VA_ARGS__); - -gboolean -gst_am_mediacodec_configure (GstAmMediaCodec * self, GstAmMediaFormat * format, - gint flags) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, configure, format->object, NULL, NULL, flags); - - return TRUE; -} - -GstAmMediaCodec * -gst_am_mediacodec_create_by_codec_name (const gchar * name) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaCodec *codec = NULL; - jobject object = NULL; - jstring name_str; - - name_str = (*env)->NewStringUTF (env, name); - if (name_str == NULL) - goto done; - - object = AMMC_STATIC_CALL (goto done, Object, createByCodecName, name_str); - if (object) { - codec = g_slice_new0 (GstAmMediaCodec); - codec->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!codec->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaCodec, codec); - codec = NULL; - } - } - -done: - if (name_str) - (*env)->DeleteLocalRef (env, name_str); - - return codec; -} - - -GstAmMediaFormat * -gst_am_mediacodec_get_output_format (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaFormat *format = NULL; - jobject object = NULL; - - object = AMMC_CALL (return NULL, Object, getOutputFormat); - if (object) { - format = g_slice_new0 (GstAmMediaFormat); - format->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!format->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaFormat, format); - return NULL; - } - } - - return format; -} - -gboolean -gst_am_mediacodec_start (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, start); - - return TRUE; -} - -gboolean -gst_am_mediacodec_stop (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, stop); - - return TRUE; -} - -gboolean -gst_am_mediacodec_flush (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, flush); - - return TRUE; -} - -void -gst_am_mediacodec_free (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - (*env)->DeleteGlobalRef (env, self->object); - g_slice_free (GstAmMediaCodec, self); -} - -void -gst_am_mediacodec_release (GstAmMediaCodec * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (, Void, release); -} - -void -gst_am_mediacodec_free_buffers (GstAmMediaCodecBuffer * buffers, - gsize n_buffers) -{ - JNIEnv *env = gst_dvm_get_env (); - jsize i; - - for (i = 0; i < n_buffers; i++) { - if (buffers[i].object) - (*env)->DeleteGlobalRef (env, buffers[i].object); - } - g_free (buffers); -} - -GstAmMediaCodecBuffer * -gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, gsize * n_buffers) -{ - JNIEnv *env = gst_dvm_get_env (); - jobject output_buffers = NULL; - jsize n_output_buffers; - GstAmMediaCodecBuffer *ret = NULL; - jsize i; - - *n_buffers = 0; - output_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); - if (!output_buffers) - goto done; - - n_output_buffers = (*env)->GetArrayLength (env, output_buffers); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get output buffers array length"); - goto done; - } - - *n_buffers = n_output_buffers; - ret = g_new0 (GstAmMediaCodecBuffer, n_output_buffers); - - for (i = 0; i < n_output_buffers; i++) { - jobject buffer = NULL; - - buffer = (*env)->GetObjectArrayElement (env, output_buffers, i); - if ((*env)->ExceptionCheck (env) || !buffer) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get output buffer %d", i); - goto error; - } - - ret[i].object = (*env)->NewGlobalRef (env, buffer); - (*env)->DeleteLocalRef (env, buffer); - if (!ret[i].object) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to create global reference %d", i); - goto error; - } - - ret[i].data = (*env)->GetDirectBufferAddress (env, ret[i].object); - if (!ret[i].data) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer address %d", i); - goto error; - } - ret[i].size = (*env)->GetDirectBufferCapacity (env, ret[i].object); - } - -done: - if (output_buffers) - (*env)->DeleteLocalRef (env, output_buffers); - output_buffers = NULL; - - return ret; -error: - if (ret) - gst_am_mediacodec_free_buffers (ret, n_output_buffers); - ret = NULL; - *n_buffers = 0; - goto done; -} - -GstAmMediaCodecBuffer * -gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, gsize * n_buffers) -{ - JNIEnv *env = gst_dvm_get_env (); - jobject input_buffers = NULL; - jsize n_input_buffers; - GstAmMediaCodecBuffer *ret = NULL; - jsize i; - - *n_buffers = 0; - - input_buffers = AMMC_CALL (goto done, Object, getOutputBuffers); - if (!input_buffers) - goto done; - - n_input_buffers = (*env)->GetArrayLength (env, input_buffers); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get input buffers array length"); - goto done; - } - - *n_buffers = n_input_buffers; - ret = g_new0 (GstAmMediaCodecBuffer, n_input_buffers); - - for (i = 0; i < n_input_buffers; i++) { - jobject buffer = NULL; - - buffer = (*env)->GetObjectArrayElement (env, input_buffers, i); - if ((*env)->ExceptionCheck (env) || !buffer) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get input buffer %d", i); - goto error; - } - - ret[i].object = (*env)->NewGlobalRef (env, buffer); - (*env)->DeleteLocalRef (env, buffer); - if (!ret[i].object) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to create global reference %d", i); - goto error; - } - - ret[i].data = (*env)->GetDirectBufferAddress (env, ret[i].object); - if (!ret[i].data) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer address %d", i); - goto error; - } - ret[i].size = (*env)->GetDirectBufferCapacity (env, ret[i].object); - } - -done: - if (input_buffers) - (*env)->DeleteLocalRef (env, input_buffers); - input_buffers = NULL; - - return ret; -error: - if (ret) - gst_am_mediacodec_free_buffers (ret, n_input_buffers); - ret = NULL; - *n_buffers = 0; - goto done; -} - -gint -gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, - gint64 timeoutUs) -{ - JNIEnv *env = gst_dvm_get_env (); - gint ret = G_MININT; - - ret = AMMC_CALL (return G_MININT, Int, dequeueInputBuffer, timeoutUs); - - return ret; -} - -#define AMMCBI_FIELD(error_statement, type, field) \ - GST_DVM_FIELD (error_statement, buffer_info, type, \ - android_media_mediacodec_bufferinfo, field); - -static gboolean -_fill_buffer_info (JNIEnv * env, jobject buffer_info, - GstAmMediaCodecBufferInfo * info) -{ - info->flags = AMMCBI_FIELD (return FALSE, Int, flags); - info->offset = AMMCBI_FIELD (return FALSE, Int, offset); - info->presentation_time_us = - AMMCBI_FIELD (return FALSE, Long, presentationTimeUs); - info->size = AMMCBI_FIELD (return FALSE, Int, size); - - return TRUE; -} - -gint -gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, - GstAmMediaCodecBufferInfo * info, gint64 timeoutUs) -{ - JNIEnv *env = gst_dvm_get_env (); - gint ret = G_MININT; - jobject info_o = NULL; - - info_o = (*env)->NewObject (env, android_media_mediacodec_bufferinfo.klass, - android_media_mediacodec_bufferinfo.constructor); - if (!info_o) { - GST_ERROR ("Failed to call Java method"); - (*env)->ExceptionClear (env); - goto done; - } - - ret = AMMC_CALL (goto error, Int, dequeueOutputBuffer, info_o, timeoutUs); - - if (!_fill_buffer_info (env, info_o, info)) - goto error; - -done: - if (info_o) - (*env)->DeleteLocalRef (env, info_o); - info_o = NULL; - - return ret; - -error: - ret = G_MININT; - goto done; -} - -gboolean -gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, gint index, - const GstAmMediaCodecBufferInfo * info) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, queueInputBuffer, index, info->offset, - info->size, info->presentation_time_us, info->flags); - - return TRUE; -} - -gboolean -gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, gint index) -{ - JNIEnv *env = gst_dvm_get_env (); - - AMMC_CALL (return FALSE, Void, releaseOutputBuffer, index, JNI_FALSE); - - return TRUE; -} diff --git a/sys/androidmedia/gst-android-media-mediacodec.h b/sys/androidmedia/gst-android-media-mediacodec.h deleted file mode 100644 index 709d0b720c..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodec.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __GST_ANDROID_MEDIA_MEDIACODEC_H__ -#define __GST_ANDROID_MEDIA_MEDIACODEC_H__ - -#include -#include - -#include "gst-android-media-mediaformat.h" - -G_BEGIN_DECLS - -typedef struct _GstAmMediaCodecBuffer GstAmMediaCodecBuffer; -typedef struct _GstAmMediaCodecBufferInfo GstAmMediaCodecBufferInfo; -typedef struct _GstAmMediaCodec GstAmMediaCodec; - -struct _GstAmMediaCodecBuffer { - guint8 *data; - gsize size; - /*< private >*/ - jobject object; /* global reference */ -}; - -struct _GstAmMediaCodecBufferInfo { - gint flags; - gint offset; - gint64 presentation_time_us; - gint size; -}; - -struct _GstAmMediaCodec { - /*< private >*/ - jobject object; /* global reference */ -}; - -extern gint MediaCodec_BUFFER_FLAG_SYNC_FRAME; -extern gint MediaCodec_BUFFER_FLAG_CODEC_CONFIG; -extern gint MediaCodec_BUFFER_FLAG_END_OF_STREAM; - -extern gint MediaCodec_CONFIGURE_FLAG_ENCODE; - -extern gint MediaCodec_INFO_TRY_AGAIN_LATER; -extern gint MediaCodec_INFO_OUTPUT_FORMAT_CHANGED; -extern gint MediaCodec_INFO_OUTPUT_BUFFERS_CHANGED; - -gboolean gst_android_media_mediacodec_init (void); -void gst_android_media_mediacodec_deinit (void); - -gboolean gst_am_mediacodec_configure (GstAmMediaCodec * self, - GstAmMediaFormat * format, gint flags); - -GstAmMediaCodec * gst_am_mediacodec_create_by_codec_name (const gchar *name); -GstAmMediaCodec * gst_am_mediacodec_create_decoder_by_type (const gchar *type); -GstAmMediaCodec * gst_am_mediacodec_create_encoder_by_type (const gchar *type); - -void gst_am_mediacodec_free (GstAmMediaCodec * self); - -gint gst_am_mediacodec_dequeue_input_buffer (GstAmMediaCodec * self, - gint64 timeoutUs); -gint gst_am_mediacodec_dequeue_output_buffer (GstAmMediaCodec * self, - GstAmMediaCodecBufferInfo *info, gint64 timeoutUs); -gboolean gst_am_mediacodec_flush (GstAmMediaCodec * self); - -GstAmMediaCodecBuffer * gst_am_mediacodec_get_input_buffers (GstAmMediaCodec * self, - gsize * n_buffers); -GstAmMediaCodecBuffer * gst_am_mediacodec_get_output_buffers (GstAmMediaCodec * self, - gsize * n_buffers); -void gst_am_mediacodec_free_buffers (GstAmMediaCodecBuffer * buffers, gsize n_buffers); -GstAmMediaFormat * gst_am_mediacodec_get_output_format (GstAmMediaCodec * self); - -gboolean gst_am_mediacodec_queue_input_buffer (GstAmMediaCodec * self, - gint index, const GstAmMediaCodecBufferInfo *info); -void gst_am_mediacodec_release (GstAmMediaCodec * self); -gboolean gst_am_mediacodec_release_output_buffer (GstAmMediaCodec * self, - gint index); - -gboolean gst_am_mediacodec_start (GstAmMediaCodec * self); -gboolean gst_am_mediacodec_stop (GstAmMediaCodec * self); - -G_END_DECLS - -#endif /* __GST_ANDROID_MEDIA_MEDIACODEC_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.c b/sys/androidmedia/gst-android-media-mediacodecinfo.c deleted file mode 100644 index abaec7326a..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodecinfo.c +++ /dev/null @@ -1,517 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include - -#include "gst-android-media-mediacodecinfo.h" - -static struct -{ - jclass klass; - jmethodID getCapabilitiesForType; - jmethodID getName; - jmethodID getSupportedTypes; - jmethodID isEncoder; -} android_media_mediacodecinfo; - -static struct -{ - jclass klass; - jfieldID colorFormats; - jfieldID profileLevels; -} android_media_mediacodeccapabilities; - -static struct -{ - jclass klass; - jfieldID level; - jfieldID profile; -} android_media_mediacodecprofilelevel; - -static struct -{ - jclass klass; - - jint CHANNEL_OUT_FRONT_LEFT; - jint CHANNEL_OUT_FRONT_RIGHT; - jint CHANNEL_OUT_FRONT_CENTER; - jint CHANNEL_OUT_LOW_FREQUENCY; - jint CHANNEL_OUT_BACK_LEFT; - jint CHANNEL_OUT_BACK_RIGHT; - jint CHANNEL_OUT_FRONT_LEFT_OF_CENTER; - jint CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; - jint CHANNEL_OUT_BACK_CENTER; - jint CHANNEL_OUT_SIDE_LEFT; - jint CHANNEL_OUT_SIDE_RIGHT; - jint CHANNEL_OUT_TOP_CENTER; - jint CHANNEL_OUT_TOP_FRONT_LEFT; - jint CHANNEL_OUT_TOP_FRONT_CENTER; - jint CHANNEL_OUT_TOP_FRONT_RIGHT; - jint CHANNEL_OUT_TOP_BACK_LEFT; - jint CHANNEL_OUT_TOP_BACK_CENTER; - jint CHANNEL_OUT_TOP_BACK_RIGHT; -} android_media_audioformat; - -gint AudioFormat_CHANNEL_OUT_FRONT_LEFT; -gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT; -gint AudioFormat_CHANNEL_OUT_FRONT_CENTER; -gint AudioFormat_CHANNEL_OUT_LOW_FREQUENCY; -gint AudioFormat_CHANNEL_OUT_BACK_LEFT; -gint AudioFormat_CHANNEL_OUT_BACK_RIGHT; -gint AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER; -gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; -gint AudioFormat_CHANNEL_OUT_BACK_CENTER; -gint AudioFormat_CHANNEL_OUT_SIDE_LEFT; -gint AudioFormat_CHANNEL_OUT_SIDE_RIGHT; -gint AudioFormat_CHANNEL_OUT_TOP_CENTER; -gint AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT; -gint AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER; -gint AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT; -gint AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT; -gint AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER; -gint AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT; - - -static gboolean -_init_classes (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - /* android.media.MediaCodecInfo */ - GST_DVM_GET_CLASS (android_media_mediacodecinfo, - "android/media/MediaCodecInfo"); - GST_DVM_GET_METHOD (android_media_mediacodecinfo, getCapabilitiesForType, - "(Ljava/lang/String;)Landroid/media/MediaCodecInfo$CodecCapabilities;"); - GST_DVM_GET_METHOD (android_media_mediacodecinfo, getName, - "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_media_mediacodecinfo, getSupportedTypes, - "()[java/lang/String;"); - GST_DVM_GET_METHOD (android_media_mediacodecinfo, isEncoder, "()Z"); - - GST_DVM_GET_CLASS (android_media_mediacodeccapabilities, - "android/media/MediaCodecInfo$CodecCapabilities"); - GST_DVM_GET_FIELD (android_media_mediacodeccapabilities, colorFormats, "[I"); - GST_DVM_GET_FIELD (android_media_mediacodeccapabilities, profileLevels, - "[Landroid/media/MediaCodecInfo$CodecProfileLevel;"); - - GST_DVM_GET_CLASS (android_media_mediacodecprofilelevel, - "android/media/MediaCodecInfo$ProfileLevel"); - GST_DVM_GET_FIELD (android_media_mediacodecprofilelevel, level, "I"); - GST_DVM_GET_FIELD (android_media_mediacodecprofilelevel, profile, "I"); - - GST_DVM_GET_CLASS (android_media_audioformat, "android/media/AudioFormat"); - - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_LEFT, Int, - "I"); - AudioFormat_CHANNEL_OUT_FRONT_LEFT = - android_media_audioformat.CHANNEL_OUT_FRONT_LEFT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_RIGHT, Int, - "I"); - AudioFormat_CHANNEL_OUT_FRONT_RIGHT = - android_media_audioformat.CHANNEL_OUT_FRONT_RIGHT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_FRONT_CENTER, - Int, "I"); - AudioFormat_CHANNEL_OUT_FRONT_CENTER = - android_media_audioformat.CHANNEL_OUT_FRONT_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_LOW_FREQUENCY, - Int, "I"); - AudioFormat_CHANNEL_OUT_LOW_FREQUENCY = - android_media_audioformat.CHANNEL_OUT_LOW_FREQUENCY; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_LEFT, Int, - "I"); - AudioFormat_CHANNEL_OUT_BACK_LEFT = - android_media_audioformat.CHANNEL_OUT_BACK_LEFT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_RIGHT, Int, - "I"); - AudioFormat_CHANNEL_OUT_BACK_RIGHT = - android_media_audioformat.CHANNEL_OUT_BACK_RIGHT; - GST_DVM_GET_CONSTANT (android_media_audioformat, - CHANNEL_OUT_FRONT_LEFT_OF_CENTER, Int, "I"); - AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = - android_media_audioformat.CHANNEL_OUT_FRONT_LEFT_OF_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, - CHANNEL_OUT_FRONT_RIGHT_OF_CENTER, Int, "I"); - AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = - android_media_audioformat.CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_BACK_CENTER, Int, - "I"); - AudioFormat_CHANNEL_OUT_BACK_CENTER = - android_media_audioformat.CHANNEL_OUT_BACK_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_SIDE_LEFT, Int, - "I"); - AudioFormat_CHANNEL_OUT_SIDE_LEFT = - android_media_audioformat.CHANNEL_OUT_SIDE_LEFT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_SIDE_RIGHT, Int, - "I"); - AudioFormat_CHANNEL_OUT_SIDE_RIGHT = - android_media_audioformat.CHANNEL_OUT_SIDE_RIGHT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_CENTER, Int, - "I"); - AudioFormat_CHANNEL_OUT_TOP_CENTER = - android_media_audioformat.CHANNEL_OUT_TOP_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_LEFT, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT = - android_media_audioformat.CHANNEL_OUT_TOP_FRONT_LEFT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_CENTER, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER = - android_media_audioformat.CHANNEL_OUT_TOP_FRONT_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_FRONT_RIGHT, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT = - android_media_audioformat.CHANNEL_OUT_TOP_FRONT_RIGHT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_LEFT, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT = - android_media_audioformat.CHANNEL_OUT_TOP_BACK_LEFT; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_CENTER, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER = - android_media_audioformat.CHANNEL_OUT_TOP_BACK_CENTER; - GST_DVM_GET_CONSTANT (android_media_audioformat, CHANNEL_OUT_TOP_BACK_RIGHT, - Int, "I"); - AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT = - android_media_audioformat.CHANNEL_OUT_TOP_BACK_RIGHT; - - return TRUE; -} - -gboolean -gst_android_media_mediacodecinfo_init (void) -{ - if (!_init_classes ()) { - gst_android_media_mediacodecinfo_deinit (); - return FALSE; - } - - return TRUE; -} - -void -gst_android_media_mediacodecinfo_deinit (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - if (android_media_mediacodecinfo.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodecinfo.klass); - android_media_mediacodecinfo.klass = NULL; - - if (android_media_mediacodeccapabilities.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodeccapabilities.klass); - android_media_mediacodeccapabilities.klass = NULL; - - if (android_media_mediacodecprofilelevel.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodecprofilelevel.klass); - android_media_mediacodecprofilelevel.klass = NULL; - - if (android_media_audioformat.klass) - (*env)->DeleteGlobalRef (env, android_media_audioformat.klass); - android_media_audioformat.klass = NULL; -} - -/* android.media.MediaCodecInfo */ -#define AMMCI_CALL(error_statement, type, method, ...) \ - GST_DVM_CALL (error_statement, self->object, type, \ - android_media_mediacodecinfo, method, ## __VA_ARGS__); - -void -gst_am_mediacodecinfo_free (GstAmMediaCodecInfo * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - (*env)->DeleteGlobalRef (env, self->object); - g_slice_free (GstAmMediaCodecInfo, self); -} - -void -gst_am_mediacodeccapabilities_free (GstAmMediaCodecCapabilities * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - (*env)->DeleteGlobalRef (env, self->object); - g_slice_free (GstAmMediaCodecCapabilities, self); -} - -void -gst_am_mediacodecprofilelevel_free (GstAmMediaCodecProfileLevel * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - (*env)->DeleteGlobalRef (env, self->object); - g_slice_free (GstAmMediaCodecProfileLevel, self); -} - - -GstAmMediaCodecCapabilities * -gst_am_mediacodecinfo_get_capabilities_for_type (GstAmMediaCodecInfo * self, - const gchar * type) -{ - JNIEnv *env = gst_dvm_get_env (); - jobject object = NULL; - jstring type_str = NULL; - GstAmMediaCodecCapabilities *caps = NULL; - - type_str = (*env)->NewStringUTF (env, type); - if (!type_str) - goto done; - - object = AMMCI_CALL (goto done, Object, getCapabilitiesForType, type_str); - - if (object) { - caps = g_slice_new0 (GstAmMediaCodecCapabilities); - caps->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!caps->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaCodecCapabilities, caps); - caps = NULL; - } - } - -done: - if (type_str) - (*env)->DeleteLocalRef (env, type_str); - - return caps; -} - -gchar * -gst_am_mediacodecinfo_get_name (GstAmMediaCodecInfo * self) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring v_str = NULL; - const gchar *v = NULL; - gchar *ret = NULL; - - v_str = AMMCI_CALL (return NULL, Object, getName); - if (v_str) { - v = (*env)->GetStringUTFChars (env, v_str, NULL); - if (!v) { - GST_ERROR ("Failed to convert string to UTF8"); - (*env)->ExceptionClear (env); - goto done; - } - ret = g_strdup (v); - } - -done: - if (v) - (*env)->ReleaseStringUTFChars (env, v_str, v); - if (v_str) - (*env)->DeleteLocalRef (env, v_str); - - return ret; -} - -GList * -gst_am_mediacodecinfo_get_supported_types (GstAmMediaCodecInfo * self) -{ - JNIEnv *env = gst_dvm_get_env (); - jarray arr = NULL; - jint arr_len = 0; - GList *ret = NULL; - gint i; - - arr = AMMCI_CALL (goto done, Object, getSupportedTypes); - if (!arr) - goto done; - arr_len = (*env)->GetArrayLength (env, arr); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array length"); - goto done; - } - - for (i = 0; i < arr_len; i++) { - jstring str = NULL; - const gchar *str_v = NULL; - - str = (*env)->GetObjectArrayElement (env, arr, i); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array element %d", i); - continue; - } - if (!str) - continue; - - str_v = (*env)->GetStringUTFChars (env, str, NULL); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get string characters"); - (*env)->DeleteLocalRef (env, str); - str = NULL; - continue; - } - ret = g_list_append (ret, g_strdup (str_v)); - (*env)->ReleaseStringUTFChars (env, str, str_v); - str_v = NULL; - (*env)->DeleteLocalRef (env, str); - str = NULL; - } - -done: - if (arr) - (*env)->DeleteLocalRef (env, arr); - - return ret; -} - -gboolean -gst_am_mediacodecinfo_is_encoder (GstAmMediaCodecInfo * self) -{ - JNIEnv *env = gst_dvm_get_env (); - gboolean ret = FALSE; - - ret = AMMCI_CALL (return FALSE, Boolean, isEncoder); - - return ret; -} - -#define AMMCC_FIELD(error_statement, type, field) \ - GST_DVM_FIELD (error_statement, self->object, type, \ - android_media_mediacodeccapabilities, field); - -GList * -gst_am_mediacodeccapabilities_get_color_formats (GstAmMediaCodecCapabilities * - self) -{ - JNIEnv *env = gst_dvm_get_env (); - GList *ret = NULL; - jarray arr = NULL; - jint arr_len = 0; - jint *arr_n = NULL; - gint i; - - arr = AMMCC_FIELD (goto done, Object, colorFormats); - arr_len = (*env)->GetArrayLength (env, arr); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array length"); - goto done; - } - - arr_n = (*env)->GetIntArrayElements (env, arr, NULL); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array elements"); - goto done; - } - - for (i = 0; i < arr_len; i++) - ret = g_list_append (ret, GINT_TO_POINTER (arr_n[i])); - -done: - if (arr_n) - (*env)->ReleaseIntArrayElements (env, arr, arr_n, JNI_ABORT); - if (arr) - (*env)->DeleteLocalRef (env, arr); - - return ret; -} - -GList * -gst_am_mediacodeccapabilities_get_profile_levels (GstAmMediaCodecCapabilities * - self) -{ - JNIEnv *env = gst_dvm_get_env (); - jarray arr = NULL; - jint arr_len = 0; - GList *ret = NULL; - gint i; - - arr = AMMCC_FIELD (goto done, Object, profileLevels); - if (!arr) - goto done; - arr_len = (*env)->GetArrayLength (env, arr); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array length"); - goto done; - } - - for (i = 0; i < arr_len; i++) { - jobject object = NULL; - - object = (*env)->GetObjectArrayElement (env, arr, i); - if ((*env)->ExceptionCheck (env)) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get array element %d", i); - continue; - } - if (!object) - continue; - - if (object) { - GstAmMediaCodecProfileLevel *profile_level = - g_slice_new0 (GstAmMediaCodecProfileLevel); - - profile_level->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - object = NULL; - if (!profile_level->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaCodecProfileLevel, profile_level); - } else { - ret = g_list_append (ret, profile_level); - } - } - } - -done: - if (arr) - (*env)->DeleteLocalRef (env, arr); - - return ret; -} - -#define AMMCPL_FIELD(error_statement, type, field) \ - GST_DVM_FIELD (error_statement, self->object, type, \ - android_media_mediacodecprofilelevel, field); - -gint -gst_am_mediacodecprofilelevel_get_level (GstAmMediaCodecProfileLevel * self) -{ - JNIEnv *env = gst_dvm_get_env (); - gint ret; - - ret = AMMCPL_FIELD (return -1, Int, level); - - return ret; -} - -gint -gst_am_mediacodecprofilelevel_get_profile (GstAmMediaCodecProfileLevel * self) -{ - JNIEnv *env = gst_dvm_get_env (); - gint ret; - - ret = AMMCPL_FIELD (return -1, Int, profile); - - return ret; -} diff --git a/sys/androidmedia/gst-android-media-mediacodecinfo.h b/sys/androidmedia/gst-android-media-mediacodecinfo.h deleted file mode 100644 index bcdb91f770..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodecinfo.h +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ -#define __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ - -#include -#include - -G_BEGIN_DECLS - -typedef struct _GstAmMediaCodecInfo GstAmMediaCodecInfo; -typedef struct _GstAmMediaCodecCapabilities GstAmMediaCodecCapabilities; -typedef struct _GstAmMediaCodecProfileLevel GstAmMediaCodecProfileLevel; - -struct _GstAmMediaCodecInfo { - /*< private >*/ - jobject object; /* global reference */ -}; - -struct _GstAmMediaCodecCapabilities { - /*< private >*/ - jobject object; /* global reference */ -}; - -struct _GstAmMediaCodecProfileLevel { - /*< private >*/ - jobject object; /* global reference */ -}; - -gboolean gst_android_media_mediacodecinfo_init (void); -void gst_android_media_mediacodecinfo_deinit (void); - -void gst_am_mediacodecinfo_free (GstAmMediaCodecInfo * self); -void gst_am_mediacodeccapabilities_free (GstAmMediaCodecCapabilities * self); -void gst_am_mediacodecprofilelevel_free (GstAmMediaCodecProfileLevel * self); - -GstAmMediaCodecCapabilities * gst_am_mediacodecinfo_get_capabilities_for_type (GstAmMediaCodecInfo * self, const gchar *type); -gchar * gst_am_mediacodecinfo_get_name (GstAmMediaCodecInfo * self); -/* GList */ -GList * gst_am_mediacodecinfo_get_supported_types (GstAmMediaCodecInfo * self); -gboolean gst_am_mediacodecinfo_is_encoder (GstAmMediaCodecInfo * self); - -/* GList */ -GList * gst_am_mediacodeccapabilities_get_color_formats (GstAmMediaCodecCapabilities *self); -/* GList */ -GList * gst_am_mediacodeccapabilities_get_profile_levels (GstAmMediaCodecCapabilities *self); - -gint gst_am_mediacodecprofilelevel_get_level (GstAmMediaCodecProfileLevel *self); -gint gst_am_mediacodecprofilelevel_get_profile (GstAmMediaCodecProfileLevel *self); - -extern gint AudioFormat_CHANNEL_OUT_FRONT_LEFT; -extern gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT; -extern gint AudioFormat_CHANNEL_OUT_FRONT_CENTER; -extern gint AudioFormat_CHANNEL_OUT_LOW_FREQUENCY; -extern gint AudioFormat_CHANNEL_OUT_BACK_LEFT; -extern gint AudioFormat_CHANNEL_OUT_BACK_RIGHT; -extern gint AudioFormat_CHANNEL_OUT_FRONT_LEFT_OF_CENTER; -extern gint AudioFormat_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER; -extern gint AudioFormat_CHANNEL_OUT_BACK_CENTER; -extern gint AudioFormat_CHANNEL_OUT_SIDE_LEFT; -extern gint AudioFormat_CHANNEL_OUT_SIDE_RIGHT; -extern gint AudioFormat_CHANNEL_OUT_TOP_CENTER; -extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_LEFT; -extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_CENTER; -extern gint AudioFormat_CHANNEL_OUT_TOP_FRONT_RIGHT; -extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_LEFT; -extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_CENTER; -extern gint AudioFormat_CHANNEL_OUT_TOP_BACK_RIGHT; - -G_END_DECLS - -#endif /* __GST_ANDROID_MEDIA_MEDIACODECINFO_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediacodeclist.c b/sys/androidmedia/gst-android-media-mediacodeclist.c deleted file mode 100644 index dddcf13dd1..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodeclist.c +++ /dev/null @@ -1,116 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include - -#include "gst-android-media-mediacodeclist.h" - -static struct -{ - jclass klass; - jmethodID getCodecCount; - jmethodID getCodecInfoAt; -} android_media_mediacodeclist; - - -static gboolean -_init_classes (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - /* android.media.MediaCodecList */ - GST_DVM_GET_CLASS (android_media_mediacodeclist, - "android/media/MediaCodecList"); - GST_DVM_GET_STATIC_METHOD (android_media_mediacodeclist, getCodecCount, - "()I;"); - GST_DVM_GET_STATIC_METHOD (android_media_mediacodeclist, getCodecInfoAt, - "(I)Landroid/media/MediaCodecInfo;"); - - return TRUE; -} - -gboolean -gst_android_media_mediacodeclist_init (void) -{ - if (!_init_classes ()) { - gst_android_media_mediacodeclist_deinit (); - return FALSE; - } - - return TRUE; -} - -void -gst_android_media_mediacodeclist_deinit (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - if (android_media_mediacodeclist.klass) - (*env)->DeleteGlobalRef (env, android_media_mediacodeclist.klass); - android_media_mediacodeclist.klass = NULL; -} - -/* android.media.MediaFormat */ -#define AMMCL_STATIC_CALL(error_statement, type, method, ...) \ - GST_DVM_STATIC_CALL (error_statement, type, \ - android_media_mediacodeclist, method, ## __VA_ARGS__); - -gint -gst_am_mediacodeclist_get_codec_count (void) -{ - JNIEnv *env = gst_dvm_get_env (); - gint count = 0; - - count = AMMCL_STATIC_CALL (goto done, Int, getCodecCount); - -done: - - return count; -} - -GstAmMediaCodecInfo * -gst_am_mediacodeclist_get_codec_info_at (gint index) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaCodecInfo *info = NULL; - jobject object = NULL; - - object = AMMCL_STATIC_CALL (goto done, Object, getCodecInfoAt, index); - if (object) { - info = g_slice_new0 (GstAmMediaCodecInfo); - info->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!info->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaCodecInfo, info); - info = NULL; - } - } - -done: - - return info; -} diff --git a/sys/androidmedia/gst-android-media-mediacodeclist.h b/sys/androidmedia/gst-android-media-mediacodeclist.h deleted file mode 100644 index e0241022e4..0000000000 --- a/sys/androidmedia/gst-android-media-mediacodeclist.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ -#define __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ - -#include -#include - -#include "gst-android-media-mediacodecinfo.h" - -G_BEGIN_DECLS - -gboolean gst_android_media_mediacodeclist_init (void); -void gst_android_media_mediacodeclist_deinit (void); - -gint gst_am_mediacodeclist_get_codec_count (void); -GstAmMediaCodecInfo * gst_am_mediacodeclist_get_codec_info_at (int index); - -G_END_DECLS - -#endif /* __GST_ANDROID_MEDIA_MEDIACODECLIST_H__ */ diff --git a/sys/androidmedia/gst-android-media-mediaformat.c b/sys/androidmedia/gst-android-media-mediaformat.c deleted file mode 100644 index ee1529b6cb..0000000000 --- a/sys/androidmedia/gst-android-media-mediaformat.c +++ /dev/null @@ -1,554 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include -#include - -#include "gst-android-media-mediaformat.h" - -static struct -{ - jclass klass; - jmethodID constructor; - jmethodID containsKey; - jmethodID createAudioFormat; - jmethodID createVideoFormat; - jmethodID getByteBuffer; - jmethodID getFloat; - jmethodID getInteger; - jmethodID getLong; - jmethodID getString; - jmethodID setByteBuffer; - jmethodID setFloat; - jmethodID setInteger; - jmethodID setLong; - jmethodID setString; - jmethodID toString; -} android_media_mediaformat; - - -static gboolean -_init_classes (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - /* android.media.MediaFormat */ - GST_DVM_GET_CLASS (android_media_mediaformat, "android/media/MediaFormat"); - GST_DVM_GET_CONSTRUCTOR (android_media_mediaformat, constructor, "()V"); - GST_DVM_GET_STATIC_METHOD (android_media_mediaformat, createAudioFormat, - "(Ljava/lang/String;II)Landroid/media/MediaFormat;"); - GST_DVM_GET_STATIC_METHOD (android_media_mediaformat, createVideoFormat, - "(Ljava/lang/String;II)Landroid/media/MediaFormat;"); - GST_DVM_GET_METHOD (android_media_mediaformat, toString, - "()Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_media_mediaformat, containsKey, - "(Ljava/lang/String;)Z"); - GST_DVM_GET_METHOD (android_media_mediaformat, getFloat, - "(Ljava/lang/String;)F"); - GST_DVM_GET_METHOD (android_media_mediaformat, setFloat, - "(Ljava/lang/String;F)V"); - GST_DVM_GET_METHOD (android_media_mediaformat, getInteger, - "(Ljava/lang/String;)I"); - GST_DVM_GET_METHOD (android_media_mediaformat, setInteger, - "(Ljava/lang/String;I)V"); - GST_DVM_GET_METHOD (android_media_mediaformat, getLong, - "(Ljava/lang/String;)J"); - GST_DVM_GET_METHOD (android_media_mediaformat, setLong, - "(Ljava/lang/String;J)V"); - GST_DVM_GET_METHOD (android_media_mediaformat, getString, - "(Ljava/lang/String;)Ljava/lang/String;"); - GST_DVM_GET_METHOD (android_media_mediaformat, setString, - "(Ljava/lang/String;Ljava/lang/String;)V"); - GST_DVM_GET_METHOD (android_media_mediaformat, getByteBuffer, - "(Ljava/lang/String;)Ljava/nio/ByteBuffer;"); - GST_DVM_GET_METHOD (android_media_mediaformat, setByteBuffer, - "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V"); - - return TRUE; -} - -gboolean -gst_android_media_mediaformat_init (void) -{ - if (!_init_classes ()) { - gst_android_media_mediaformat_deinit (); - return FALSE; - } - - return TRUE; -} - -void -gst_android_media_mediaformat_deinit (void) -{ - JNIEnv *env = gst_dvm_get_env (); - - if (android_media_mediaformat.klass) - (*env)->DeleteGlobalRef (env, android_media_mediaformat.klass); - android_media_mediaformat.klass = NULL; -} - -/* android.media.MediaFormat */ -#define AMMF_CALL(error_statement, type, method, ...) \ - GST_DVM_CALL (error_statement, self->object, type, \ - android_media_mediaformat, method, ## __VA_ARGS__); -#define AMMF_STATIC_CALL(error_statement, type, method, ...) \ - GST_DVM_STATIC_CALL (error_statement, type, \ - android_media_mediaformat, method, ## __VA_ARGS__); - -GstAmMediaFormat * -gst_am_mediaformat_new (void) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaFormat *format = NULL; - jobject object = NULL; - - object = (*env)->NewObject (env, android_media_mediaformat.klass, - android_media_mediaformat.constructor); - if ((*env)->ExceptionCheck (env) || !object) { - GST_ERROR ("Failed to create callback object"); - (*env)->ExceptionClear (env); - return NULL; - } - - format = g_slice_new0 (GstAmMediaFormat); - format->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!format->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaFormat, format); - return NULL; - } - - return format; -} - -GstAmMediaFormat * -gst_am_mediaformat_create_audio_format (const gchar * mime, - gint sample_rate, gint channels) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaFormat *format = NULL; - jstring mime_str; - jobject object = NULL; - - mime_str = (*env)->NewStringUTF (env, mime); - if (mime_str == NULL) - goto done; - - object = AMMF_STATIC_CALL (goto done, Object, createAudioFormat, mime_str, - sample_rate, channels); - if (object) { - format = g_slice_new0 (GstAmMediaFormat); - format->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!format->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaFormat, format); - format = NULL; - } - } - -done: - if (mime_str) - (*env)->DeleteLocalRef (env, mime_str); - - return format; -} - -GstAmMediaFormat * -gst_am_mediaformat_create_video_format (const gchar * mime, - gint width, gint height) -{ - JNIEnv *env = gst_dvm_get_env (); - GstAmMediaFormat *format = NULL; - jstring mime_str; - jobject object = NULL; - - mime_str = (*env)->NewStringUTF (env, mime); - if (mime_str == NULL) - goto done; - - object = AMMF_STATIC_CALL (goto done, Object, createVideoFormat, mime_str, - width, height); - if (object) { - format = g_slice_new0 (GstAmMediaFormat); - format->object = (*env)->NewGlobalRef (env, object); - (*env)->DeleteLocalRef (env, object); - if (!format->object) { - GST_ERROR ("Failed to create global reference"); - (*env)->ExceptionClear (env); - g_slice_free (GstAmMediaFormat, format); - format = NULL; - } - } - -done: - if (mime_str) - (*env)->DeleteLocalRef (env, mime_str); - - return format; -} - -void -gst_am_mediaformat_free (GstAmMediaFormat * self) -{ - JNIEnv *env = gst_dvm_get_env (); - - (*env)->DeleteGlobalRef (env, self->object); - g_slice_free (GstAmMediaFormat, self); -} - -gchar * -gst_am_mediaformat_to_string (GstAmMediaFormat * self) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring v_str = NULL; - const gchar *v = NULL; - gchar *ret = NULL; - - v_str = AMMF_CALL (return NULL, Object, toString); - if (v_str) { - v = (*env)->GetStringUTFChars (env, v_str, NULL); - if (!v) { - GST_ERROR ("Failed to convert string to UTF8"); - (*env)->ExceptionClear (env); - goto done; - } - ret = g_strdup (v); - } - -done: - if (v) - (*env)->ReleaseStringUTFChars (env, v_str, v); - if (v_str) - (*env)->DeleteLocalRef (env, v_str); - - return ret; -} - -gboolean -gst_am_mediaformat_contains_key (GstAmMediaFormat * self, const gchar * key) -{ - JNIEnv *env = gst_dvm_get_env (); - gboolean ret = FALSE; - jstring key_str = NULL; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - ret = AMMF_CALL (ret = FALSE; goto done, Boolean, containsKey, key_str); - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; -} - -gboolean -gst_am_mediaformat_get_float (GstAmMediaFormat * self, const gchar * key, - gfloat * value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - - *value = 0; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - *value = AMMF_CALL (goto done, Float, getFloat, key_str); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; -} - -gboolean -gst_am_mediaformat_set_float (GstAmMediaFormat * self, const gchar * key, - gfloat value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - AMMF_CALL (goto done, Void, setFloat, key_str, value); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; -} - -gboolean -gst_am_mediaformat_get_int (GstAmMediaFormat * self, const gchar * key, - gint * value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - - *value = 0; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - *value = AMMF_CALL (goto done, Int, getInteger, key_str); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; - -} - -gboolean -gst_am_mediaformat_set_int (GstAmMediaFormat * self, const gchar * key, - gint value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - AMMF_CALL (goto done, Void, setInteger, key_str, value); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; -} - -gboolean -gst_am_mediaformat_get_long (GstAmMediaFormat * self, const gchar * key, - glong * value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - jlong long_value; - - *value = 0; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - long_value = AMMF_CALL (goto done, Long, getLong, key_str); - *value = long_value; - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; - -} - -gboolean -gst_am_mediaformat_set_long (GstAmMediaFormat * self, const gchar * key, - glong value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - gboolean ret = FALSE; - jlong long_value = value; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - AMMF_CALL (goto done, Void, setLong, key_str, long_value); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - - return ret; -} - -gboolean -gst_am_mediaformat_get_string (GstAmMediaFormat * self, const gchar * key, - gchar ** value) -{ - JNIEnv *env = gst_dvm_get_env (); - gboolean ret = FALSE; - jstring key_str = NULL; - jstring v_str = NULL; - const gchar *v = NULL; - - *value = 0; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - v_str = AMMF_CALL (goto done, Object, getString, key_str); - - v = (*env)->GetStringUTFChars (env, v_str, NULL); - if (!v) { - GST_ERROR ("Failed to convert string to UTF8"); - (*env)->ExceptionClear (env); - goto done; - } - - *value = g_strdup (v); - - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - if (v) - (*env)->ReleaseStringUTFChars (env, v_str, v); - if (v_str) - (*env)->DeleteLocalRef (env, v_str); - - return ret; -} - -gboolean -gst_am_mediaformat_set_string (GstAmMediaFormat * self, const gchar * key, - const gchar * value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - jstring v_str = NULL; - gboolean ret = FALSE; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - v_str = (*env)->NewStringUTF (env, value); - if (!v_str) - goto done; - - AMMF_CALL (goto done, Void, setString, key_str, v_str); - ret = TRUE; -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - if (v_str) - (*env)->DeleteLocalRef (env, v_str); - - return ret; -} - -gboolean -gst_am_mediaformat_get_buffer (GstAmMediaFormat * self, const gchar * key, - GstBuffer ** value) -{ - JNIEnv *env = gst_dvm_get_env (); - gboolean ret = FALSE; - jstring key_str = NULL; - jobject v = NULL; - guint8 *data; - gsize size; - - *value = 0; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - v = AMMF_CALL (goto done, Object, getByteBuffer, key_str); - - data = (*env)->GetDirectBufferAddress (env, v); - if (!data) { - (*env)->ExceptionClear (env); - GST_ERROR ("Failed to get buffer address"); - goto done; - } - size = (*env)->GetDirectBufferCapacity (env, v); - *value = gst_buffer_new_and_alloc (size); - memcpy (GST_BUFFER_DATA (*value), data, size); - - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - if (v) - (*env)->DeleteLocalRef (env, v); - - return ret; -} - -gboolean -gst_am_mediaformat_set_buffer (GstAmMediaFormat * self, const gchar * key, - GstBuffer * value) -{ - JNIEnv *env = gst_dvm_get_env (); - jstring key_str = NULL; - jobject v = NULL; - gboolean ret = FALSE; - - key_str = (*env)->NewStringUTF (env, key); - if (!key_str) - goto done; - - /* FIXME: The buffer must remain valid until the codec is stopped */ - v = (*env)->NewDirectByteBuffer (env, GST_BUFFER_DATA (value), - GST_BUFFER_SIZE (value)); - if (!v) - goto done; - - AMMF_CALL (goto done, Void, setByteBuffer, key_str, v); - ret = TRUE; - -done: - if (key_str) - (*env)->DeleteLocalRef (env, key_str); - if (v) - (*env)->DeleteLocalRef (env, v); - - return ret; -} diff --git a/sys/androidmedia/gst-android-media-mediaformat.h b/sys/androidmedia/gst-android-media-mediaformat.h deleted file mode 100644 index a909d12737..0000000000 --- a/sys/androidmedia/gst-android-media-mediaformat.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (C) 2012, Collabora Ltd. - * Author: Sebastian Dröge - * Author: Youness Alaoui - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - */ - -#ifndef __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ -#define __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ - -#include -#include - -G_BEGIN_DECLS - -typedef struct _GstAmMediaFormat GstAmMediaFormat; - -struct _GstAmMediaFormat { - /*< private >*/ - jobject object; /* global reference */ -}; - -gboolean gst_android_media_mediaformat_init (void); -void gst_android_media_mediaformat_deinit (void); - -GstAmMediaFormat * gst_am_mediaformat_new (void); -GstAmMediaFormat * gst_am_mediaformat_create_audio_format (const gchar *mime, - gint sample_rate, gint channels); -GstAmMediaFormat * gst_am_mediaformat_create_video_format (const gchar *mime, - gint width, gint height); -void gst_am_mediaformat_free (GstAmMediaFormat * self); - -gboolean gst_am_mediaformat_get_float (GstAmMediaFormat * self, - const gchar *key, gfloat *value); -gboolean gst_am_mediaformat_set_float (GstAmMediaFormat * self, - const gchar *key, gfloat value); -gboolean gst_am_mediaformat_get_int (GstAmMediaFormat * self, - const gchar *key, gint *value); -gboolean gst_am_mediaformat_set_int (GstAmMediaFormat * self, - const gchar *key, gint value); -gboolean gst_am_mediaformat_get_long (GstAmMediaFormat * self, - const gchar *key, glong *value); -gboolean gst_am_mediaformat_set_long (GstAmMediaFormat * self, - const gchar *key, glong value); -gboolean gst_am_mediaformat_get_string (GstAmMediaFormat * self, - const gchar *key, gchar **value); -gboolean gst_am_mediaformat_set_string (GstAmMediaFormat * self, - const gchar *key, const gchar *value); -gboolean gst_am_mediaformat_get_buffer (GstAmMediaFormat * self, - const gchar *key, GstBuffer **value); -gboolean gst_am_mediaformat_set_buffer (GstAmMediaFormat * self, - const gchar *key, GstBuffer *value); - - -gboolean gst_am_mediaformat_contains_key (GstAmMediaFormat * self, - const gchar *key); -gchar * gst_am_mediaformat_to_string (GstAmMediaFormat * self); - -G_END_DECLS - -#endif /* __GST_ANDROID_MEDIA_MEDIAFORMAT_H__ */ diff --git a/sys/androidmedia/gstahcsrc.c b/sys/androidmedia/gstahcsrc.c index a61c60b780..d67ea03aea 100644 --- a/sys/androidmedia/gstahcsrc.c +++ b/sys/androidmedia/gstahcsrc.c @@ -69,11 +69,10 @@ # include "config.h" #endif -#define GST_USE_UNSTABLE_API #include -#include #include -#include + +#include "gstjniutils.h" #include "gstahcsrc.h" @@ -89,9 +88,9 @@ static GstStateChangeReturn gst_ahc_src_change_state (GstElement * element, GstStateChange transition); /* GstBaseSrc */ -static GstCaps *gst_ahc_src_getcaps (GstBaseSrc * src); +static GstCaps *gst_ahc_src_getcaps (GstBaseSrc * src, GstCaps * filter); static gboolean gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps); -static void gst_ahc_src_fixate (GstBaseSrc * basesrc, GstCaps * caps); +static GstCaps *gst_ahc_src_fixate (GstBaseSrc * basesrc, GstCaps * caps); static gboolean gst_ahc_src_start (GstBaseSrc * bsrc); static gboolean gst_ahc_src_stop (GstBaseSrc * bsrc); static gboolean gst_ahc_src_unlock (GstBaseSrc * bsrc); @@ -99,58 +98,54 @@ static gboolean gst_ahc_src_unlock_stop (GstBaseSrc * bsrc); static GstFlowReturn gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer); static gboolean gst_ahc_src_query (GstBaseSrc * bsrc, GstQuery * query); -/* GstPropertyProbe */ -static void gst_ahc_src_implements_interface_init (GstImplementsInterfaceClass - * klass); -static void gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface - * iface); -static void gst_ahc_src_photography_interface_init (GstPhotographyInterface - * iface); -static void gst_ahc_src_init_interfaces (GType type); - /* GstPhotography */ +static void gst_ahc_src_photography_init (gpointer g_iface, + gpointer iface_data); static gboolean gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp); static gboolean _white_balance_to_enum (const gchar * white_balance, - GstWhiteBalanceMode * mode); + GstPhotographyWhiteBalanceMode * mode); static gboolean gst_ahc_src_get_white_balance_mode (GstPhotography * photo, - GstWhiteBalanceMode * wb_mode); + GstPhotographyWhiteBalanceMode * wb_mode); static gboolean _color_effects_to_enum (const gchar * color_effect, - GstColourToneMode * mode); + GstPhotographyColorToneMode * mode); static gboolean gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, - GstColourToneMode * tone_mode); -static gboolean _scene_modes_to_enum (const gchar * scene, GstSceneMode * mode); + GstPhotographyColorToneMode * tone_mode); +static gboolean _scene_modes_to_enum (const gchar * scene, + GstPhotographySceneMode * mode); static gboolean gst_ahc_src_get_scene_mode (GstPhotography * photo, - GstSceneMode * scene_mode); -static gboolean _flash_modes_to_enum (const gchar * flash, GstFlashMode * mode); + GstPhotographySceneMode * scene_mode); +static gboolean _flash_modes_to_enum (const gchar * flash, + GstPhotographyFlashMode * mode); static gboolean gst_ahc_src_get_flash_mode (GstPhotography * photo, - GstFlashMode * flash_mode); + GstPhotographyFlashMode * flash_mode); static gboolean gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom); static gboolean _antibanding_to_enum (const gchar * antibanding, - GstFlickerReductionMode * mode); + GstPhotographyFlickerReductionMode * mode); static gboolean gst_ahc_src_get_flicker_mode (GstPhotography * photo, - GstFlickerReductionMode * flicker_mode); -static gboolean _focus_modes_to_enum (const gchar * focus, GstFocusMode * mode); + GstPhotographyFlickerReductionMode * flicker_mode); +static gboolean _focus_modes_to_enum (const gchar * focus, + GstPhotographyFocusMode * mode); static gboolean gst_ahc_src_get_focus_mode (GstPhotography * photo, - GstFocusMode * focus_mode); + GstPhotographyFocusMode * focus_mode); static gboolean gst_ahc_src_set_ev_compensation (GstPhotography * photo, gfloat ev_comp); static gboolean gst_ahc_src_set_white_balance_mode (GstPhotography * photo, - GstWhiteBalanceMode wb_mode); + GstPhotographyWhiteBalanceMode wb_mode); static gboolean gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, - GstColourToneMode tone_mode); + GstPhotographyColorToneMode tone_mode); static gboolean gst_ahc_src_set_scene_mode (GstPhotography * photo, - GstSceneMode scene_mode); + GstPhotographySceneMode scene_mode); static gboolean gst_ahc_src_set_flash_mode (GstPhotography * photo, - GstFlashMode flash_mode); + GstPhotographyFlashMode flash_mode); static gboolean gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom); static gboolean gst_ahc_src_set_flicker_mode (GstPhotography * photo, - GstFlickerReductionMode flicker_mode); + GstPhotographyFlickerReductionMode flicker_mode); static gboolean gst_ahc_src_set_focus_mode (GstPhotography * photo, - GstFocusMode focus_mode); + GstPhotographyFocusMode focus_mode); -static GstPhotoCaps gst_ahc_src_get_capabilities (GstPhotography * photo); +static GstPhotographyCaps gst_ahc_src_get_capabilities (GstPhotography * photo); static void gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on); /* GstAHCSrc */ @@ -162,8 +157,7 @@ static void gst_ahc_src_on_auto_focus (gboolean success, gpointer user_data); #define NUM_CALLBACK_BUFFERS 5 #define GST_AHC_SRC_CAPS_STR \ - GST_VIDEO_CAPS_YUV (" { YV12 , YUY2 , NV21 , NV16 }") ";" \ - GST_VIDEO_CAPS_RGB_16 + GST_VIDEO_CAPS_MAKE_WITH_FEATURES("ANY", " { YV12, YUY2, NV21, NV16, RGB16 }") static GstStaticPadTemplate gst_ahc_src_pad_template = GST_STATIC_PAD_TEMPLATE ("src", @@ -174,6 +168,8 @@ GST_STATIC_PAD_TEMPLATE ("src", GST_DEBUG_CATEGORY_STATIC (gst_ahc_src_debug); #define GST_CAT_DEFAULT gst_ahc_src_debug +#define parent_class gst_ahc_src_parent_class + enum { PROP_0, @@ -194,13 +190,20 @@ enum PROP_EV_COMP, PROP_ISO_SPEED, PROP_APERTURE, - PROP_EXPOSURE, + PROP_EXPOSURE_MODE, PROP_IMAGE_CAPTURE_SUPPORTED_CAPS, PROP_IMAGE_PREVIEW_SUPPORTED_CAPS, PROP_FLICKER_MODE, PROP_FOCUS_MODE, PROP_ZOOM, PROP_SMOOTH_ZOOM, + PROP_WHITE_POINT, + PROP_MIN_EXPOSURE_TIME, + PROP_MAX_EXPOSURE_TIME, + PROP_LENS_FOCUS, + PROP_EXPOSURE_TIME, + PROP_COLOR_TEMPERATURE, + PROP_ANALOG_GAIN, PROP_LAST }; @@ -208,8 +211,8 @@ static GParamSpec *properties[PROP_LAST]; #define DEFAULT_DEVICE "0" -GST_BOILERPLATE_FULL (GstAHCSrc, gst_ahc_src, GstPushSrc, GST_TYPE_PUSH_SRC, - gst_ahc_src_init_interfaces); +G_DEFINE_TYPE_WITH_CODE (GstAHCSrc, gst_ahc_src, GST_TYPE_PUSH_SRC, + G_IMPLEMENT_INTERFACE (GST_TYPE_PHOTOGRAPHY, gst_ahc_src_photography_init)); #define CAMERA_FACING_BACK 0 #define CAMERA_FACING_FRONT 1 @@ -233,47 +236,30 @@ gst_ahc_src_facing_get_type (void) #define GST_AHC_SRC_FACING_TYPE (gst_ahc_src_facing_get_type()) static void -gst_ahc_src_init_interfaces (GType type) +gst_ahc_src_photography_init (gpointer g_iface, gpointer iface_data) { - static const GInterfaceInfo ahcsrc_propertyprobe_info = { - (GInterfaceInitFunc) gst_ahc_src_property_probe_interface_init, - NULL, - NULL, - }; - static const GInterfaceInfo ahcsrc_photography_info = { - (GInterfaceInitFunc) gst_ahc_src_photography_interface_init, - NULL, - NULL, - }; - static const GInterfaceInfo ahcsrc_implements_interface_info = { - (GInterfaceInitFunc) gst_ahc_src_implements_interface_init, - NULL, - NULL, - }; + GstPhotographyInterface *iface = g_iface; - g_type_add_interface_static (type, GST_TYPE_PROPERTY_PROBE, - &ahcsrc_propertyprobe_info); - g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE, - &ahcsrc_implements_interface_info); - g_type_add_interface_static (type, GST_TYPE_PHOTOGRAPHY, - &ahcsrc_photography_info); -} + iface->get_ev_compensation = gst_ahc_src_get_ev_compensation; + iface->get_white_balance_mode = gst_ahc_src_get_white_balance_mode; + iface->get_color_tone_mode = gst_ahc_src_get_colour_tone_mode; + iface->get_scene_mode = gst_ahc_src_get_scene_mode; + iface->get_flash_mode = gst_ahc_src_get_flash_mode; + iface->get_zoom = gst_ahc_src_get_zoom; + iface->get_flicker_mode = gst_ahc_src_get_flicker_mode; + iface->get_focus_mode = gst_ahc_src_get_focus_mode; -static void -gst_ahc_src_base_init (gpointer g_class) -{ - GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class); + iface->set_ev_compensation = gst_ahc_src_set_ev_compensation; + iface->set_white_balance_mode = gst_ahc_src_set_white_balance_mode; + iface->set_color_tone_mode = gst_ahc_src_set_colour_tone_mode; + iface->set_scene_mode = gst_ahc_src_set_scene_mode; + iface->set_flash_mode = gst_ahc_src_set_flash_mode; + iface->set_zoom = gst_ahc_src_set_zoom; + iface->set_flicker_mode = gst_ahc_src_set_flicker_mode; + iface->set_focus_mode = gst_ahc_src_set_focus_mode; - GST_DEBUG_CATEGORY_INIT (gst_ahc_src_debug, "ahcsrc", 0, - "android.hardware.Camera source element"); - - gst_element_class_add_static_pad_template (gstelement_class, - &gst_ahc_src_pad_template); - gst_element_class_set_details_simple (gstelement_class, - "Android Camera Source", - "Source/Video", - "Reads frames from android.hardware.Camera class into buffers", - "Youness Alaoui "); + iface->get_capabilities = gst_ahc_src_get_capabilities; + iface->set_autofocus = gst_ahc_src_set_autofocus; } static void @@ -301,6 +287,9 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) gstpushsrc_class->create = gst_ahc_src_create; + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_ahc_src_pad_template)); + /** * GstAHCSrc:device: * @@ -420,9 +409,9 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) GST_PHOTOGRAPHY_PROP_WB_MODE); g_object_class_override_property (gobject_class, PROP_COLOUR_TONE, - GST_PHOTOGRAPHY_PROP_COLOUR_TONE); + GST_PHOTOGRAPHY_PROP_COLOR_TONE); properties[PROP_COLOUR_TONE] = g_object_class_find_property (gobject_class, - GST_PHOTOGRAPHY_PROP_COLOUR_TONE); + GST_PHOTOGRAPHY_PROP_COLOR_TONE); g_object_class_override_property (gobject_class, PROP_SCENE_MODE, GST_PHOTOGRAPHY_PROP_SCENE_MODE); @@ -460,10 +449,12 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) properties[PROP_APERTURE] = g_object_class_find_property (gobject_class, GST_PHOTOGRAPHY_PROP_APERTURE); - g_object_class_override_property (gobject_class, PROP_EXPOSURE, - GST_PHOTOGRAPHY_PROP_EXPOSURE); +#if 0 + g_object_class_override_property (gobject_class, PROP_EXPOSURE_MODE, + GST_PHOTOGRAPHY_PROP_EXPOSURE_MODE); properties[PROP_EXPOSURE] = g_object_class_find_property (gobject_class, - GST_PHOTOGRAPHY_PROP_EXPOSURE); + GST_PHOTOGRAPHY_PROP_EXPOSURE_MODE); +#endif g_object_class_override_property (gobject_class, PROP_IMAGE_CAPTURE_SUPPORTED_CAPS, @@ -494,7 +485,56 @@ gst_ahc_src_class_init (GstAHCSrcClass * klass) properties[PROP_ZOOM] = g_object_class_find_property (gobject_class, GST_PHOTOGRAPHY_PROP_ZOOM); + g_object_class_override_property (gobject_class, PROP_WHITE_POINT, + GST_PHOTOGRAPHY_PROP_WHITE_POINT); + properties[PROP_WHITE_POINT] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_WHITE_POINT); + + g_object_class_override_property (gobject_class, PROP_MIN_EXPOSURE_TIME, + GST_PHOTOGRAPHY_PROP_MIN_EXPOSURE_TIME); + properties[PROP_MIN_EXPOSURE_TIME] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_MIN_EXPOSURE_TIME); + + g_object_class_override_property (gobject_class, PROP_MAX_EXPOSURE_TIME, + GST_PHOTOGRAPHY_PROP_MAX_EXPOSURE_TIME); + properties[PROP_MAX_EXPOSURE_TIME] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_MAX_EXPOSURE_TIME); + + g_object_class_override_property (gobject_class, PROP_LENS_FOCUS, + GST_PHOTOGRAPHY_PROP_LENS_FOCUS); + properties[PROP_LENS_FOCUS] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_LENS_FOCUS); + + g_object_class_override_property (gobject_class, PROP_EXPOSURE_TIME, + GST_PHOTOGRAPHY_PROP_EXPOSURE_TIME); + properties[PROP_EXPOSURE_TIME] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_EXPOSURE_TIME); + + g_object_class_override_property (gobject_class, PROP_COLOR_TEMPERATURE, + GST_PHOTOGRAPHY_PROP_COLOR_TEMPERATURE); + properties[PROP_COLOR_TEMPERATURE] = + g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_COLOR_TEMPERATURE); + + g_object_class_override_property (gobject_class, PROP_ANALOG_GAIN, + GST_PHOTOGRAPHY_PROP_ANALOG_GAIN); + properties[PROP_ANALOG_GAIN] = g_object_class_find_property (gobject_class, + GST_PHOTOGRAPHY_PROP_ANALOG_GAIN); + + + klass->probe_properties = NULL; + + gst_element_class_set_static_metadata (element_class, + "Android Camera Source", + "Source/Video", + "Reads frames from android.hardware.Camera class into buffers", + "Youness Alaoui "); + + GST_DEBUG_CATEGORY_INIT (gst_ahc_src_debug, "ahcsrc", 0, + "android.hardware.Camera source element"); } static gboolean @@ -505,7 +545,7 @@ _data_queue_check_full (GstDataQueue * queue, guint visible, } static void -gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) +gst_ahc_src_init (GstAHCSrc * self) { gst_base_src_set_live (GST_BASE_SRC (self), TRUE); gst_base_src_set_format (GST_BASE_SRC (self), GST_FORMAT_TIME); @@ -514,9 +554,11 @@ gst_ahc_src_init (GstAHCSrc * self, GstAHCSrcClass * klass) self->camera = NULL; self->texture = NULL; self->data = NULL; - self->queue = gst_data_queue_new (_data_queue_check_full, NULL); + self->queue = gst_data_queue_new (_data_queue_check_full, NULL, NULL, NULL); self->start = FALSE; self->previous_ts = GST_CLOCK_TIME_NONE; + + g_mutex_init (&self->mutex); } static void @@ -528,6 +570,8 @@ gst_ahc_src_dispose (GObject * object) g_object_unref (self->queue); self->queue = NULL; + g_mutex_clear (&self->mutex); + G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -536,7 +580,8 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAHCSrc *self = GST_AHC_SRC (object); - (void) self; + + GST_DEBUG_OBJECT (self, "set props %d", prop_id); switch (prop_id) { case PROP_DEVICE:{ @@ -566,25 +611,25 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, self->smooth_zoom = g_value_get_boolean (value); break; case PROP_WB_MODE:{ - GstWhiteBalanceMode wb = g_value_get_enum (value); + GstPhotographyWhiteBalanceMode wb = g_value_get_enum (value); gst_ahc_src_set_white_balance_mode (GST_PHOTOGRAPHY (self), wb); } break; case PROP_COLOUR_TONE:{ - GstColourToneMode tone = g_value_get_enum (value); + GstPhotographyColorToneMode tone = g_value_get_enum (value); gst_ahc_src_set_colour_tone_mode (GST_PHOTOGRAPHY (self), tone); } break; case PROP_SCENE_MODE:{ - GstSceneMode scene = g_value_get_enum (value); + GstPhotographySceneMode scene = g_value_get_enum (value); gst_ahc_src_set_scene_mode (GST_PHOTOGRAPHY (self), scene); } break; case PROP_FLASH_MODE:{ - GstFlashMode flash = g_value_get_enum (value); + GstPhotographyFlashMode flash = g_value_get_enum (value); gst_ahc_src_set_flash_mode (GST_PHOTOGRAPHY (self), flash); } @@ -596,13 +641,13 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, } break; case PROP_FLICKER_MODE:{ - GstFlickerReductionMode flicker = g_value_get_enum (value); + GstPhotographyFlickerReductionMode flicker = g_value_get_enum (value); gst_ahc_src_set_flicker_mode (GST_PHOTOGRAPHY (self), flicker); } break; case PROP_FOCUS_MODE:{ - GstFocusMode focus = g_value_get_enum (value); + GstPhotographyFocusMode focus = g_value_get_enum (value); gst_ahc_src_set_focus_mode (GST_PHOTOGRAPHY (self), focus); } @@ -616,9 +661,16 @@ gst_ahc_src_set_property (GObject * object, guint prop_id, case PROP_NOISE_REDUCTION: case PROP_ISO_SPEED: case PROP_APERTURE: - case PROP_EXPOSURE: + case PROP_EXPOSURE_MODE: case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: + case PROP_WHITE_POINT: + case PROP_MIN_EXPOSURE_TIME: + case PROP_MAX_EXPOSURE_TIME: + case PROP_LENS_FOCUS: + case PROP_EXPOSURE_TIME: + case PROP_COLOR_TEMPERATURE: + case PROP_ANALOG_GAIN: break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -724,35 +776,35 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, g_value_set_boolean (value, self->smooth_zoom); break; case PROP_WB_MODE:{ - GstWhiteBalanceMode wb; + GstPhotographyWhiteBalanceMode wb; if (gst_ahc_src_get_white_balance_mode (GST_PHOTOGRAPHY (self), &wb)) g_value_set_enum (value, wb); } break; case PROP_COLOUR_TONE:{ - GstColourToneMode tone; + GstPhotographyColorToneMode tone; if (gst_ahc_src_get_colour_tone_mode (GST_PHOTOGRAPHY (self), &tone)) g_value_set_enum (value, tone); } break; case PROP_SCENE_MODE:{ - GstSceneMode scene; + GstPhotographySceneMode scene; if (gst_ahc_src_get_scene_mode (GST_PHOTOGRAPHY (self), &scene)) g_value_set_enum (value, scene); } break; case PROP_FLASH_MODE:{ - GstFlashMode flash; + GstPhotographyFlashMode flash; if (gst_ahc_src_get_flash_mode (GST_PHOTOGRAPHY (self), &flash)) g_value_set_enum (value, flash); } break; case PROP_CAPABILITIES:{ - GstPhotoCaps caps; + GstPhotographyCaps caps; caps = gst_ahc_src_get_capabilities (GST_PHOTOGRAPHY (self)); g_value_set_ulong (value, caps); @@ -766,14 +818,14 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } break; case PROP_FLICKER_MODE:{ - GstFlickerReductionMode flicker; + GstPhotographyFlickerReductionMode flicker; if (gst_ahc_src_get_flicker_mode (GST_PHOTOGRAPHY (self), &flicker)) g_value_set_enum (value, flicker); } break; case PROP_FOCUS_MODE:{ - GstFocusMode focus; + GstPhotographyFocusMode focus; if (gst_ahc_src_get_focus_mode (GST_PHOTOGRAPHY (self), &focus)) g_value_set_enum (value, focus); @@ -791,7 +843,14 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, case PROP_NOISE_REDUCTION: case PROP_ISO_SPEED: case PROP_APERTURE: - case PROP_EXPOSURE: + case PROP_EXPOSURE_MODE: + case PROP_WHITE_POINT: + case PROP_MIN_EXPOSURE_TIME: + case PROP_MAX_EXPOSURE_TIME: + case PROP_LENS_FOCUS: + case PROP_EXPOSURE_TIME: + case PROP_COLOR_TEMPERATURE: + case PROP_ANALOG_GAIN: break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -799,23 +858,7 @@ gst_ahc_src_get_property (GObject * object, guint prop_id, } } -static gboolean -gst_ahc_src_interface_supported (GstImplementsInterface * iface, - GType iface_type) -{ - if (iface_type == GST_TYPE_PHOTOGRAPHY || - iface_type == GST_TYPE_PROPERTY_PROBE) - return TRUE; - else - return FALSE; -} - -static void -gst_ahc_src_implements_interface_init (GstImplementsInterfaceClass * klass) -{ - klass->supported = gst_ahc_src_interface_supported; -} - +#if 0 static const GList * gst_ahc_src_probe_get_properties (GstPropertyProbe * probe) { @@ -952,36 +995,33 @@ gst_ahc_src_probe_get_values (GstPropertyProbe * probe, } } else if (pspec == properties[PROP_WB_MODE]) { PROBE_GET_ENUM_VALUES (white_balance, GST_TYPE_WHITE_BALANCE_MODE, - GstWhiteBalanceMode); + GstPhotographyWhiteBalanceMode); } else if (pspec == properties[PROP_COLOUR_TONE]) { PROBE_GET_ENUM_VALUES (color_effects, GST_TYPE_COLOUR_TONE_MODE, - GstColourToneMode); + GstPhotographyColorToneMode); } else if (pspec == properties[PROP_FLASH_MODE]) { - PROBE_GET_ENUM_VALUES (flash_modes, GST_TYPE_FLASH_MODE, GstFlashMode); + PROBE_GET_ENUM_VALUES (flash_modes, GST_TYPE_FLASH_MODE, + GstPhotographyFlashMode); } else if (pspec == properties[PROP_FOCUS_MODE]) { - PROBE_GET_ENUM_VALUES (focus_modes, GST_TYPE_FOCUS_MODE, GstFocusMode); + PROBE_GET_ENUM_VALUES (focus_modes, GST_TYPE_FOCUS_MODE, + GstPhotographyFocusMode); } else if (pspec == properties[PROP_SCENE_MODE]) { - PROBE_GET_ENUM_VALUES (scene_modes, GST_TYPE_SCENE_MODE, GstSceneMode); + PROBE_GET_ENUM_VALUES (scene_modes, GST_TYPE_SCENE_MODE, + GstPhotographySceneMode); } else if (pspec == properties[PROP_FLICKER_MODE]) { PROBE_GET_ENUM_VALUES (antibanding, GST_TYPE_FLICKER_REDUCTION_MODE, - GstFlickerReductionMode); + GstPhotographyFlickerReductionMode); } else { G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); } return array; } - -static void -gst_ahc_src_property_probe_interface_init (GstPropertyProbeInterface * iface) -{ - iface->get_properties = gst_ahc_src_probe_get_properties; - iface->get_values = gst_ahc_src_probe_get_values; -} - +#endif static gboolean -_antibanding_to_enum (const gchar * antibanding, GstFlickerReductionMode * mode) +_antibanding_to_enum (const gchar * antibanding, + GstPhotographyFlickerReductionMode * mode) { if (antibanding == Parameters_ANTIBANDING_AUTO) *mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; @@ -998,7 +1038,8 @@ _antibanding_to_enum (const gchar * antibanding, GstFlickerReductionMode * mode) } static gboolean -_white_balance_to_enum (const gchar * white_balance, GstWhiteBalanceMode * mode) +_white_balance_to_enum (const gchar * white_balance, + GstPhotographyWhiteBalanceMode * mode) { if (white_balance == Parameters_WHITE_BALANCE_AUTO) *mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; @@ -1023,26 +1064,27 @@ _white_balance_to_enum (const gchar * white_balance, GstWhiteBalanceMode * mode) } static gboolean -_color_effects_to_enum (const gchar * color_effect, GstColourToneMode * mode) +_color_effects_to_enum (const gchar * color_effect, + GstPhotographyColorToneMode * mode) { if (color_effect == Parameters_EFFECT_NONE) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL; else if (color_effect == Parameters_EFFECT_MONO) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_GRAYSCALE; else if (color_effect == Parameters_EFFECT_NEGATIVE) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_NEGATIVE; else if (color_effect == Parameters_EFFECT_SOLARIZE) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_SOLARIZE; else if (color_effect == Parameters_EFFECT_SEPIA) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_SEPIA; else if (color_effect == Parameters_EFFECT_POSTERIZE) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_POSTERIZE; else if (color_effect == Parameters_EFFECT_WHITEBOARD) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_WHITEBOARD; else if (color_effect == Parameters_EFFECT_BLACKBOARD) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_BLACKBOARD; else if (color_effect == Parameters_EFFECT_AQUA) - *mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA; + *mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_AQUA; else return FALSE; @@ -1050,7 +1092,7 @@ _color_effects_to_enum (const gchar * color_effect, GstColourToneMode * mode) } static gboolean -_scene_modes_to_enum (const gchar * scene, GstSceneMode * mode) +_scene_modes_to_enum (const gchar * scene, GstPhotographySceneMode * mode) { if (scene == Parameters_SCENE_MODE_AUTO) *mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; @@ -1091,7 +1133,7 @@ _scene_modes_to_enum (const gchar * scene, GstSceneMode * mode) } static gboolean -_flash_modes_to_enum (const gchar * flash, GstFlashMode * mode) +_flash_modes_to_enum (const gchar * flash, GstPhotographyFlashMode * mode) { if (flash == Parameters_FLASH_MODE_OFF) *mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; @@ -1110,7 +1152,7 @@ _flash_modes_to_enum (const gchar * flash, GstFlashMode * mode) } static gboolean -_focus_modes_to_enum (const gchar * focus, GstFocusMode * mode) +_focus_modes_to_enum (const gchar * focus, GstPhotographyFocusMode * mode) { if (focus == Parameters_FOCUS_MODE_AUTO) *mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; @@ -1165,7 +1207,7 @@ gst_ahc_src_get_ev_compensation (GstPhotography * photo, gfloat * ev_comp) static gboolean gst_ahc_src_get_white_balance_mode (GstPhotography * photo, - GstWhiteBalanceMode * wb_mode) + GstPhotographyWhiteBalanceMode * wb_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1176,7 +1218,7 @@ gst_ahc_src_get_white_balance_mode (GstPhotography * photo, params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *wb = gst_ahc_parameters_get_white_balance (params); - GstWhiteBalanceMode mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; + GstPhotographyWhiteBalanceMode mode = GST_PHOTOGRAPHY_WB_MODE_AUTO; if (_white_balance_to_enum (wb, &mode)) { ret = TRUE; @@ -1194,7 +1236,7 @@ gst_ahc_src_get_white_balance_mode (GstPhotography * photo, static gboolean gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, - GstColourToneMode * tone_mode) + GstPhotographyColorToneMode * tone_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1205,7 +1247,7 @@ gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *effect = gst_ahc_parameters_get_color_effect (params); - GstColourToneMode mode = GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL; + GstPhotographyColorToneMode mode = GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL; if (_color_effects_to_enum (effect, &mode)) { ret = TRUE; @@ -1222,7 +1264,8 @@ gst_ahc_src_get_colour_tone_mode (GstPhotography * photo, } static gboolean -gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) +gst_ahc_src_get_scene_mode (GstPhotography * photo, + GstPhotographySceneMode * scene_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1233,7 +1276,7 @@ gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *scene = gst_ahc_parameters_get_scene_mode (params); - GstSceneMode mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; + GstPhotographySceneMode mode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO; if (_scene_modes_to_enum (scene, &mode)) { ret = TRUE; @@ -1250,7 +1293,8 @@ gst_ahc_src_get_scene_mode (GstPhotography * photo, GstSceneMode * scene_mode) } static gboolean -gst_ahc_src_get_flash_mode (GstPhotography * photo, GstFlashMode * flash_mode) +gst_ahc_src_get_flash_mode (GstPhotography * photo, + GstPhotographyFlashMode * flash_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1261,7 +1305,7 @@ gst_ahc_src_get_flash_mode (GstPhotography * photo, GstFlashMode * flash_mode) params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *flash = gst_ahc_parameters_get_flash_mode (params); - GstFlashMode mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; + GstPhotographyFlashMode mode = GST_PHOTOGRAPHY_FLASH_MODE_OFF; if (_flash_modes_to_enum (flash, &mode)) { ret = TRUE; @@ -1313,7 +1357,7 @@ gst_ahc_src_get_zoom (GstPhotography * photo, gfloat * zoom) static gboolean gst_ahc_src_get_flicker_mode (GstPhotography * photo, - GstFlickerReductionMode * flicker_mode) + GstPhotographyFlickerReductionMode * flicker_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1324,7 +1368,8 @@ gst_ahc_src_get_flicker_mode (GstPhotography * photo, params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *antibanding = gst_ahc_parameters_get_antibanding (params); - GstFlickerReductionMode mode = GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; + GstPhotographyFlickerReductionMode mode = + GST_PHOTOGRAPHY_FLICKER_REDUCTION_AUTO; if (_antibanding_to_enum (antibanding, &mode)) { ret = TRUE; @@ -1341,7 +1386,8 @@ gst_ahc_src_get_flicker_mode (GstPhotography * photo, } static gboolean -gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode) +gst_ahc_src_get_focus_mode (GstPhotography * photo, + GstPhotographyFocusMode * focus_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1352,7 +1398,7 @@ gst_ahc_src_get_focus_mode (GstPhotography * photo, GstFocusMode * focus_mode) params = gst_ah_camera_get_parameters (self->camera); if (params) { const gchar *focus = gst_ahc_parameters_get_focus_mode (params); - GstFocusMode mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; + GstPhotographyFocusMode mode = GST_PHOTOGRAPHY_FOCUS_MODE_AUTO; if (_focus_modes_to_enum (focus, &mode)) { ret = TRUE; @@ -1404,7 +1450,7 @@ gst_ahc_src_set_ev_compensation (GstPhotography * photo, gfloat ev_comp) static gboolean gst_ahc_src_set_white_balance_mode (GstPhotography * photo, - GstWhiteBalanceMode wb_mode) + GstPhotographyWhiteBalanceMode wb_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1459,7 +1505,7 @@ gst_ahc_src_set_white_balance_mode (GstPhotography * photo, static gboolean gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, - GstColourToneMode tone_mode) + GstPhotographyColorToneMode tone_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1472,40 +1518,40 @@ gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, const gchar *color_effect = NULL; switch (tone_mode) { - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NORMAL: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL: color_effect = Parameters_EFFECT_NONE; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SEPIA: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_SEPIA: color_effect = Parameters_EFFECT_SEPIA; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NEGATIVE: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_NEGATIVE: color_effect = Parameters_EFFECT_NEGATIVE; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRAYSCALE: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_GRAYSCALE: color_effect = Parameters_EFFECT_MONO; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SOLARIZE: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_SOLARIZE: color_effect = Parameters_EFFECT_SOLARIZE; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_POSTERIZE: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_POSTERIZE: color_effect = Parameters_EFFECT_POSTERIZE; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_WHITEBOARD: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_WHITEBOARD: color_effect = Parameters_EFFECT_WHITEBOARD; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_BLACKBOARD: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_BLACKBOARD: color_effect = Parameters_EFFECT_BLACKBOARD; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_AQUA: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_AQUA: color_effect = Parameters_EFFECT_AQUA; break; - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_NATURAL: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_VIVID: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_COLORSWAP: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_OUT_OF_FOCUS: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SKY_BLUE: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_GRASS_GREEN: - case GST_PHOTOGRAPHY_COLOUR_TONE_MODE_SKIN_WHITEN: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_NATURAL: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_VIVID: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_COLORSWAP: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_OUT_OF_FOCUS: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_SKY_BLUE: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_GRASS_GREEN: + case GST_PHOTOGRAPHY_COLOR_TONE_MODE_SKIN_WHITEN: default: color_effect = NULL; break; @@ -1523,7 +1569,8 @@ gst_ahc_src_set_colour_tone_mode (GstPhotography * photo, } static gboolean -gst_ahc_src_set_scene_mode (GstPhotography * photo, GstSceneMode scene_mode) +gst_ahc_src_set_scene_mode (GstPhotography * photo, + GstPhotographySceneMode scene_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1603,7 +1650,8 @@ gst_ahc_src_set_scene_mode (GstPhotography * photo, GstSceneMode scene_mode) } static gboolean -gst_ahc_src_set_flash_mode (GstPhotography * photo, GstFlashMode flash_mode) +gst_ahc_src_set_flash_mode (GstPhotography * photo, + GstPhotographyFlashMode flash_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1696,7 +1744,7 @@ gst_ahc_src_set_zoom (GstPhotography * photo, gfloat zoom) static gboolean gst_ahc_src_set_flicker_mode (GstPhotography * photo, - GstFlickerReductionMode flicker_mode) + GstPhotographyFlickerReductionMode flicker_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1738,7 +1786,8 @@ gst_ahc_src_set_flicker_mode (GstPhotography * photo, } static gboolean -gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) +gst_ahc_src_set_focus_mode (GstPhotography * photo, + GstPhotographyFocusMode focus_mode) { GstAHCSrc *self = GST_AHC_SRC (photo); gboolean ret = FALSE; @@ -1789,12 +1838,12 @@ gst_ahc_src_set_focus_mode (GstPhotography * photo, GstFocusMode focus_mode) return ret; } -static GstPhotoCaps +static GstPhotographyCaps gst_ahc_src_get_capabilities (GstPhotography * photo) { GstAHCSrc *self = GST_AHC_SRC (photo); - GstPhotoCaps caps = GST_PHOTOGRAPHY_CAPS_EV_COMP | + GstPhotographyCaps caps = GST_PHOTOGRAPHY_CAPS_EV_COMP | GST_PHOTOGRAPHY_CAPS_WB_MODE | GST_PHOTOGRAPHY_CAPS_TONE | GST_PHOTOGRAPHY_CAPS_SCENE | GST_PHOTOGRAPHY_CAPS_FLASH | GST_PHOTOGRAPHY_CAPS_FOCUS | GST_PHOTOGRAPHY_CAPS_ZOOM; @@ -1820,7 +1869,7 @@ gst_ahc_src_on_auto_focus (gboolean success, gpointer user_data) GST_WARNING_OBJECT (self, "Auto focus completed : %d", success); gst_element_post_message (GST_ELEMENT (self), gst_message_new_custom (GST_MESSAGE_ELEMENT, GST_OBJECT (self), - gst_structure_new (GST_PHOTOGRAPHY_AUTOFOCUS_DONE, NULL))); + gst_structure_new_empty (GST_PHOTOGRAPHY_AUTOFOCUS_DONE))); } static void @@ -1837,31 +1886,6 @@ gst_ahc_src_set_autofocus (GstPhotography * photo, gboolean on) } -static void -gst_ahc_src_photography_interface_init (GstPhotographyInterface * iface) -{ - iface->get_ev_compensation = gst_ahc_src_get_ev_compensation; - iface->get_white_balance_mode = gst_ahc_src_get_white_balance_mode; - iface->get_colour_tone_mode = gst_ahc_src_get_colour_tone_mode; - iface->get_scene_mode = gst_ahc_src_get_scene_mode; - iface->get_flash_mode = gst_ahc_src_get_flash_mode; - iface->get_zoom = gst_ahc_src_get_zoom; - iface->get_flicker_mode = gst_ahc_src_get_flicker_mode; - iface->get_focus_mode = gst_ahc_src_get_focus_mode; - - iface->set_ev_compensation = gst_ahc_src_set_ev_compensation; - iface->set_white_balance_mode = gst_ahc_src_set_white_balance_mode; - iface->set_colour_tone_mode = gst_ahc_src_set_colour_tone_mode; - iface->set_scene_mode = gst_ahc_src_set_scene_mode; - iface->set_flash_mode = gst_ahc_src_set_flash_mode; - iface->set_zoom = gst_ahc_src_set_zoom; - iface->set_flicker_mode = gst_ahc_src_set_flicker_mode; - iface->set_focus_mode = gst_ahc_src_set_focus_mode; - - iface->get_capabilities = gst_ahc_src_get_capabilities; - iface->set_autofocus = gst_ahc_src_set_autofocus; -} - static gint _compare_formats (int f1, int f2) { @@ -1900,7 +1924,7 @@ _compare_ranges (int *r1, int *r2) } static GstCaps * -gst_ahc_src_getcaps (GstBaseSrc * src) +gst_ahc_src_getcaps (GstBaseSrc * src, GstCaps * filter) { GstAHCSrc *self = GST_AHC_SRC (src); @@ -1924,6 +1948,7 @@ gst_ahc_src_getcaps (GstBaseSrc * src) for (i = formats; i; i = i->next) { int f = GPOINTER_TO_INT (i->data); + gchar *format_string = NULL; GstStructure *format = NULL; /* Ignore duplicates */ @@ -1933,36 +1958,31 @@ gst_ahc_src_getcaps (GstBaseSrc * src) /* Can't use switch/case because the values are not constants */ if (f == ImageFormat_NV16) { GST_DEBUG_OBJECT (self, " NV16 (%d)", f); - format = gst_structure_new ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '6'), - NULL); + format_string = g_strdup ("NV16"); } else if (f == ImageFormat_NV21) { GST_DEBUG_OBJECT (self, " NV21 (%d)", f); - format = gst_structure_new ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '2', '1'), - NULL); + format_string = g_strdup ("NV21"); } else if (f == ImageFormat_RGB_565) { + GstVideoFormat vformat; + vformat = gst_video_format_from_masks (16, 16, G_LITTLE_ENDIAN, + 0xf800, 0x07e0, 0x001f, 0x0); GST_DEBUG_OBJECT (self, " RGB565 (%d)", f); - format = gst_structure_new ("video/x-raw-rgb", - "bpp", G_TYPE_INT, 16, - "depth", G_TYPE_INT, 16, - "red_mask", G_TYPE_INT, 0xf800, - "green_mask", G_TYPE_INT, 0x07e0, - "blue_mask", G_TYPE_INT, 0x001f, - "endianness", G_TYPE_INT, G_LITTLE_ENDIAN, NULL); + format_string = g_strdup (gst_video_format_to_string (vformat)); } else if (f == ImageFormat_YUY2) { GST_DEBUG_OBJECT (self, " YUY2 (%d)", f); - format = gst_structure_new ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'), - NULL); + format_string = g_strdup ("YUY2"); } else if (f == ImageFormat_YV12) { GST_DEBUG_OBJECT (self, " YV12 (%d)", f); - format = gst_structure_new ("video/x-raw-yuv", - "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'V', '1', '2'), - NULL); + format_string = g_strdup ("YV12"); } previous_format = f; + if (format_string) { + format = gst_structure_new ("video/x-raw", + "format", G_TYPE_STRING, format_string, NULL); + g_free (format_string); + } + if (format) { for (j = sizes; j; j = j->next) { GstAHCSize *s = j->data; @@ -2018,7 +2038,7 @@ gst_ahc_src_getcaps (GstBaseSrc * src) } } -static void +static GstCaps * gst_ahc_src_fixate (GstBaseSrc * src, GstCaps * caps) { GstAHCSrc *self = GST_AHC_SRC (src); @@ -2026,12 +2046,18 @@ gst_ahc_src_fixate (GstBaseSrc * src, GstCaps * caps) GST_DEBUG_OBJECT (self, "Fixating : %" GST_PTR_FORMAT, caps); + caps = gst_caps_make_writable (caps); + /* Width/height will be fixed already here, format will * be left for fixation by the default handler. * We only have to fixate framerate here, to the * highest possible framerate. */ gst_structure_fixate_field_nearest_fraction (s, "framerate", G_MAXINT, 1); + + caps = GST_BASE_SRC_CLASS (parent_class)->fixate (src, caps); + + return caps; } static gboolean @@ -2048,17 +2074,23 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) params = gst_ah_camera_get_parameters (self->camera); if (params) { + GstStructure *s; + const gchar *format_str = NULL; GstVideoFormat format; gint fmt; gint width, height, fps_n, fps_d, buffer_size; GList *ranges, *l; gint range_size = G_MAXINT; - if (!gst_video_format_parse_caps (caps, &format, &width, &height) || - !gst_video_parse_caps_framerate (caps, &fps_n, &fps_d)) { - GST_WARNING_OBJECT (self, "unable to parse video caps"); - goto end; - } + s = gst_caps_get_structure (caps, 0); + + format_str = gst_structure_get_string (s, "format"); + format = gst_video_format_from_string (format_str); + + gst_structure_get_int (s, "width", &width); + gst_structure_get_int (s, "height", &height); + gst_structure_get_fraction (s, "framerate", &fps_n, &fps_d); + fps_n *= 1000 / fps_d; /* Select the best range that contains our framerate. @@ -2110,7 +2142,7 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) } if (fmt == ImageFormat_UNKNOWN) { - GST_WARNING_OBJECT (self, "unsupported video format"); + GST_WARNING_OBJECT (self, "unsupported video format (%s)", format_str); goto end; } @@ -2132,8 +2164,9 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) self->format = fmt; buffer_size = width * height * ((double) gst_ag_imageformat_get_bits_per_pixel (fmt) / 8); + if (buffer_size > self->buffer_size) { - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); gint i; for (i = 0; i < NUM_CALLBACK_BUFFERS; i++) { @@ -2146,6 +2179,10 @@ gst_ahc_src_setcaps (GstBaseSrc * src, GstCaps * caps) } } self->buffer_size = buffer_size; + + GST_DEBUG_OBJECT (self, "setting buffer w:%d h:%d buffer_size: %d", + self->width, self->height, self->buffer_size); + ret = TRUE; } @@ -2180,20 +2217,29 @@ gst_ahc_src_buffer_free_func (gpointer priv) { FreeFuncBuffer *data = (FreeFuncBuffer *) priv; GstAHCSrc *self = data->self; - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); + + g_mutex_lock (&self->mutex); + + GST_DEBUG_OBJECT (self, "release %p->%p", data, data->array); (*env)->ReleaseByteArrayElements (env, data->array, data->data, JNI_ABORT); if (self->camera) gst_ah_camera_add_callback_buffer (self->camera, data->array); + (*env)->DeleteGlobalRef (env, data->array); - gst_object_unref (self); g_slice_free (FreeFuncBuffer, data); + + g_mutex_unlock (&self->mutex); + gst_object_unref (self); } static void _data_queue_item_free (GstDataQueueItem * item) { + GST_DEBUG ("release %p", item->object); + gst_buffer_unref (GST_BUFFER (item->object)); g_slice_free (GstDataQueueItem, item); } @@ -2202,7 +2248,7 @@ static void gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) { GstAHCSrc *self = GST_AHC_SRC (user_data); - JNIEnv *env = gst_dvm_get_env (); + JNIEnv *env = gst_amc_jni_get_env (); GstBuffer *buffer; GstDataQueueItem *item = NULL; FreeFuncBuffer *malloc_data = NULL; @@ -2210,9 +2256,12 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) GstClockTime duration = 0; GstClock *clock; + + g_mutex_lock (&self->mutex); + if (array == NULL) { GST_DEBUG_OBJECT (self, "Size of array in queue is too small, dropping it"); - return; + goto done; } if ((clock = GST_ELEMENT_CLOCK (self))) { @@ -2230,37 +2279,50 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) /* Drop the first buffer */ self->previous_ts = current_ts; gst_ah_camera_add_callback_buffer (self->camera, array); - return; + GST_DEBUG_OBJECT (self, "dropping the first buffer"); + goto done; } } else { + GST_DEBUG_OBJECT (self, "element clock hasn't created yet."); gst_ah_camera_add_callback_buffer (self->camera, array); - return; + goto done; } - //GST_WARNING_OBJECT (self, "Received data buffer %p", data); + + GST_DEBUG_OBJECT (self, "Received data buffer %p", array); + malloc_data = g_slice_new0 (FreeFuncBuffer); malloc_data->self = gst_object_ref (self); malloc_data->array = (*env)->NewGlobalRef (env, array); malloc_data->data = (*env)->GetByteArrayElements (env, array, NULL); - buffer = gst_buffer_new (); - GST_BUFFER_DATA (buffer) = (guint8 *) malloc_data->data; - GST_BUFFER_SIZE (buffer) = self->buffer_size; - GST_BUFFER_MALLOCDATA (buffer) = (gpointer) malloc_data; - GST_BUFFER_FREE_FUNC (buffer) = gst_ahc_src_buffer_free_func; + buffer = + gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY, malloc_data->data, + self->buffer_size, 0, self->buffer_size, malloc_data, + gst_ahc_src_buffer_free_func); GST_BUFFER_DURATION (buffer) = duration; - GST_BUFFER_TIMESTAMP (buffer) = timestamp; + GST_BUFFER_PTS (buffer) = timestamp; + + GST_DEBUG_OBJECT (self, "creating wrapped buffer (size: %d)", + self->buffer_size); item = g_slice_new0 (GstDataQueueItem); item->object = GST_MINI_OBJECT (buffer); - item->size = GST_BUFFER_SIZE (buffer); + item->size = gst_buffer_get_size (buffer); item->duration = GST_BUFFER_DURATION (buffer); item->visible = TRUE; item->destroy = (GDestroyNotify) _data_queue_item_free; + GST_DEBUG_OBJECT (self, "wrapping jni array %p->%p %p->%p", item, + item->object, malloc_data, malloc_data->array); + if (!gst_data_queue_push (self->queue, item)) { + GST_INFO_OBJECT (self, "can't add buffer to queue"); /* Can't add buffer to queue. Must be flushing. */ _data_queue_item_free (item); } + +done: + g_mutex_unlock (&self->mutex); } static void @@ -2408,8 +2470,12 @@ gst_ahc_src_create (GstPushSrc * src, GstBuffer ** buffer) GstAHCSrc *self = GST_AHC_SRC (src); GstDataQueueItem *item; - if (!gst_data_queue_pop (self->queue, &item)) - return GST_FLOW_WRONG_STATE; + if (!gst_data_queue_pop (self->queue, &item)) { + GST_INFO_OBJECT (self, "empty queue"); + return GST_FLOW_FLUSHING; + } + + GST_DEBUG_OBJECT (self, "creating buffer %p->%p", item, item->object); *buffer = GST_BUFFER (item->object); g_slice_free (GstDataQueueItem, item); diff --git a/sys/androidmedia/gstahcsrc.h b/sys/androidmedia/gstahcsrc.h index 005cd36704..fc24989277 100644 --- a/sys/androidmedia/gstahcsrc.h +++ b/sys/androidmedia/gstahcsrc.h @@ -3,6 +3,9 @@ * Copyright (C) 2012, Cisco Systems, Inc. * Author: Youness Alaoui * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either @@ -68,6 +71,7 @@ struct _GstAHCSrc gint fps_max; gboolean start; gboolean smooth_zoom; + GMutex mutex; /* Properties */ gint device; diff --git a/sys/androidmedia/gstamc.c b/sys/androidmedia/gstamc.c index f333820789..5a72e0e1d5 100644 --- a/sys/androidmedia/gstamc.c +++ b/sys/androidmedia/gstamc.c @@ -29,6 +29,8 @@ #define orc_memcpy memcpy #endif +#include "gstahcsrc.h" + #include "gstamc.h" #include "gstamc-constants.h" @@ -3316,6 +3318,28 @@ plugin_init (GstPlugin * plugin) if (!register_codecs (plugin)) return FALSE; + if (!gst_android_graphics_surfacetexture_init ()) { + GST_ERROR ("Failed to init android surface texture"); + return FALSE; + } + + if (!gst_android_graphics_imageformat_init ()) { + GST_ERROR ("Failed to init android image format"); + gst_android_graphics_surfacetexture_deinit (); + return FALSE; + } + + if (!gst_android_hardware_camera_init ()) { + gst_android_graphics_surfacetexture_deinit (); + gst_android_graphics_imageformat_deinit (); + return FALSE; + } + + if (!gst_element_register (plugin, "ahcsrc", GST_RANK_NONE, GST_TYPE_AHC_SRC)) { + GST_ERROR ("Failed to register android camera source"); + return FALSE; + } + return TRUE; } diff --git a/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java new file mode 100644 index 0000000000..53811a9d33 --- /dev/null +++ b/sys/androidmedia/org/freedesktop/gstreamer/androidmedia/GstAhcCallback.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2012, Collabora Ltd. + * Author: Youness Alaoui + * + * Copyright (C) 2015, Collabora Ltd. + * Author: Justin Kim + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +package org.freedesktop.gstreamer.androidmedia; + +import android.hardware.Camera; + +public class GstAhcCallback implements Camera.PreviewCallback, + Camera.ErrorCallback, + Camera.AutoFocusCallback { + public long mUserData; + public long mCallback; + + public static native void gst_ah_camera_on_preview_frame(byte[] data, Camera camera, + long callback, long user_data); + public static native void gst_ah_camera_on_error(int error, Camera camera, + long callback, long user_data); + public static native void gst_ah_camera_on_auto_focus(boolean success, Camera camera, + long callback, long user_data); + + public GstAhcCallback(long callback, long user_data) { + mCallback = callback; + mUserData = user_data; + } + + @Override + public void onPreviewFrame(byte[] data, Camera camera) { + gst_ah_camera_on_preview_frame(data, camera, mCallback, mUserData); + } + + @Override + public void onError(int error, Camera camera) { + gst_ah_camera_on_error(error, camera, mCallback, mUserData); + } + + @Override + public void onAutoFocus(boolean success, Camera camera) { + gst_ah_camera_on_auto_focus(success, camera, mCallback, mUserData); + } +} From 9a53d798765b54ff8e9e5acb25b13d4a3bc22edf Mon Sep 17 00:00:00 2001 From: George Kiagiadakis Date: Mon, 7 Dec 2015 14:31:40 +0100 Subject: [PATCH 81/82] ahcsrc: fix deadlock when flushing _data_queue_item_free() calls gst_buffer_unref(), which calls gst_ahc_src_buffer_free_func(), which calls g_mutex_lock() on self->mutex and there you go... deadlock! --- sys/androidmedia/gstahcsrc.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/sys/androidmedia/gstahcsrc.c b/sys/androidmedia/gstahcsrc.c index d67ea03aea..127060036a 100644 --- a/sys/androidmedia/gstahcsrc.c +++ b/sys/androidmedia/gstahcsrc.c @@ -2255,7 +2255,7 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) GstClockTime timestamp = GST_CLOCK_TIME_NONE; GstClockTime duration = 0; GstClock *clock; - + gboolean queued = FALSE; g_mutex_lock (&self->mutex); @@ -2315,14 +2315,16 @@ gst_ahc_src_on_preview_frame (jbyteArray array, gpointer user_data) GST_DEBUG_OBJECT (self, "wrapping jni array %p->%p %p->%p", item, item->object, malloc_data, malloc_data->array); - if (!gst_data_queue_push (self->queue, item)) { - GST_INFO_OBJECT (self, "can't add buffer to queue"); - /* Can't add buffer to queue. Must be flushing. */ - _data_queue_item_free (item); - } + queued = gst_data_queue_push (self->queue, item); done: g_mutex_unlock (&self->mutex); + + if (item && !queued) { + GST_INFO_OBJECT (self, "could not add buffer to queue"); + /* Can't add buffer to queue. Must be flushing. */ + _data_queue_item_free (item); + } } static void From 09dbc5b2989f414f7921e39045cc7e97146178b6 Mon Sep 17 00:00:00 2001 From: Nicolas Dufresne Date: Fri, 8 Jan 2016 16:16:09 -0500 Subject: [PATCH 82/82] ahcsrc: Fix latency reporting Currently it was wrongly reporting min/max as being the shortest and longest possible frame duration. This is not how latency works in GStreamer. Fix by reporting min latency as being the longest possible duration of one frame. As we don't know how many buffers the stack can accumulate, we simply assume that max latency is the same (the usual default behaviour). --- sys/androidmedia/gstahcsrc.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/sys/androidmedia/gstahcsrc.c b/sys/androidmedia/gstahcsrc.c index 127060036a..bb87289819 100644 --- a/sys/androidmedia/gstahcsrc.c +++ b/sys/androidmedia/gstahcsrc.c @@ -2492,15 +2492,14 @@ gst_ahc_src_query (GstBaseSrc * bsrc, GstQuery * query) switch (GST_QUERY_TYPE (query)) { case GST_QUERY_LATENCY:{ - GstClockTime min, max; + GstClockTime min; - gst_query_parse_latency (query, NULL, &min, &max); - min = gst_util_uint64_scale (GST_SECOND, 1000, self->fps_max); - max = gst_util_uint64_scale (GST_SECOND, 1000, self->fps_min); + /* Allow of 1 frame latency base on the longer frame duration */ + gst_query_parse_latency (query, NULL, &min, NULL); + min = gst_util_uint64_scale (GST_SECOND, 1000, self->fps_min); GST_DEBUG_OBJECT (self, - "Reporting latency min: %" GST_TIME_FORMAT " max: %" GST_TIME_FORMAT, - GST_TIME_ARGS (min), GST_TIME_ARGS (max)); - gst_query_set_latency (query, TRUE, min, max); + "Reporting latency min: %" GST_TIME_FORMAT, GST_TIME_ARGS (min)); + gst_query_set_latency (query, TRUE, min, min); return TRUE; break;