libjava/jni/gtk-peer/gnu_java_awt_peer_gtk_GdkPixbufDecoder.c

   1 /* gdkpixbufdecoder.c
   2    Copyright (C) 1999, 2003, 2004 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Classpath.
   5
   6    GNU Classpath is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    GNU Classpath is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GNU Classpath; see the file COPYING.  If not, write to the
  18    Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.
  20
  21    Linking this library statically or dynamically with other modules is
  22    making a combined work based on this library.  Thus, the terms and
  23    conditions of the GNU General Public License cover the whole
  24    combination.
  25
  26    As a special exception, the copyright holders of this library give you
  27    permission to link this library with independent modules to produce an
  28    executable, regardless of the license terms of these independent
  29    modules, and to copy and distribute the resulting executable under
  30    terms of your choice, provided that you also meet, for each linked
  31    independent module, the terms and conditions of the license of that
  32    module.  An independent module is a module which is not derived from
  33    or based on this library.  If you modify this library, you may extend
  34    this exception to your version of the library, but you are not
  35    obligated to do so.  If you do not wish to do so, delete this
  36    exception statement from your version. */
  37
  38 #include <gtkpeer.h>
  39 #include <gdk/gdk.h>
  40 #include <gdk-pixbuf/gdk-pixbuf.h>
  41 #include <gdk-pixbuf/gdk-pixbuf-loader.h>
  42
  43 #include <jni.h>
  44 #include "native_state.h"
  45 #include "gnu_java_awt_peer_gtk_GdkPixbufDecoder.h"
  46
  47 #include <string.h>
  48 #include <stdlib.h>
  49
  50 struct state_table *native_pixbufdecoder_state_table;
  51
  52 /* Union used for type punning. */
  53 union env_union
  54 {
  55   void **void_env;
  56   JNIEnv **jni_env;
  57 };
  58
  59 static JavaVM *vm;
  60
  61 static jmethodID areaPreparedID;
  62 static jmethodID areaUpdatedID;
  63 static jmethodID dataOutputWriteID;
  64 static jmethodID registerFormatID;
  65
  66 static void
  67 area_prepared (GdkPixbufLoader *loader,
  68                jobject *decoder)
  69 {
  70   JNIEnv *env;
  71   union env_union e;
  72   jint width, height;
  73
  74   GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
  75   if (pixbuf == NULL)
  76     return;
  77
  78   width = gdk_pixbuf_get_width (pixbuf);
  79   height = gdk_pixbuf_get_height (pixbuf);
  80
  81   gdk_threads_leave ();
  82
  83   g_assert (decoder != NULL);
  84
  85   e.jni_env = &env;
  86   (*vm)->GetEnv (vm, e.void_env, JNI_VERSION_1_1);
  87   (*env)->CallVoidMethod (env,
  88                           *decoder,
  89                           areaPreparedID,
  90                           width, height);
  91
  92   gdk_threads_enter ();
  93 }
  94
  95 static void
  96 area_updated (GdkPixbufLoader *loader,
  97               gint x, gint y,
  98               gint width, gint height,
  99               jobject *decoder)
 100 {
 101   JNIEnv *env;
 102   union env_union e;
 103   jint stride_bytes, stride_pixels, n_channels, n_pixels;
 104   jintArray jpixels;
 105   jint *java_pixels;
 106   guchar *gdk_pixels;
 107
 108   GdkPixbuf *pixbuf_no_alpha = NULL;
 109   GdkPixbuf *pixbuf = NULL;
 110
 111 #ifndef WORDS_BIGENDIAN
 112   int i;
 113 #endif
 114
 115   pixbuf_no_alpha = gdk_pixbuf_loader_get_pixbuf (loader);
 116   if (pixbuf_no_alpha == NULL)
 117     return;
 118
 119   pixbuf = gdk_pixbuf_add_alpha(pixbuf_no_alpha, FALSE, 0, 0, 0);
 120   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
 121
 122   stride_bytes = gdk_pixbuf_get_rowstride (pixbuf);
 123   n_channels = gdk_pixbuf_get_n_channels (pixbuf);
 124   stride_pixels =  stride_bytes / n_channels;
 125   n_pixels = height * stride_pixels;
 126   gdk_pixels = gdk_pixbuf_get_pixels (pixbuf);
 127
 128   e.jni_env = &env;
 129   (*vm)->GetEnv (vm, e.void_env, JNI_VERSION_1_1);
 130   jpixels = (*env)->NewIntArray (env, n_pixels);
 131   java_pixels = (*env)->GetIntArrayElements (env, jpixels, NULL);
 132
 133   memcpy (java_pixels,
 134           gdk_pixels + (y * stride_bytes),
 135           (height * stride_bytes));
 136
 137 #ifndef WORDS_BIGENDIAN
 138   /* convert pixels from 0xBBGGRRAA to 0xAARRGGBB */
 139   for (i = 0; i < n_pixels; ++i)
 140     {
 141       java_pixels[i] = SWAPU32 ((unsigned)java_pixels[i]);
 142     }
 143 #endif
 144
 145   g_object_unref (pixbuf);
 146
 147   gdk_threads_leave ();
 148
 149   (*env)->ReleaseIntArrayElements (env, jpixels, java_pixels, 0);
 150   (*env)->CallVoidMethod (env,
 151                           *decoder,
 152                           areaUpdatedID,
 153                           (jint) x, (jint) y,
 154                           (jint) width, (jint) height,
 155                           jpixels,
 156                           stride_pixels);
 157   gdk_threads_enter ();
 158 }
 159
 160 static void
 161 closed (GdkPixbufLoader *loader __attribute__((unused)), jobject *decoder)
 162 {
 163   JNIEnv *env;
 164   union env_union e;
 165   e.jni_env = &env;
 166   (*vm)->GetEnv (vm, e.void_env, JNI_VERSION_1_1);
 167
 168   gdk_threads_leave ();
 169   (*env)->DeleteGlobalRef (env, *decoder);
 170   free (decoder);
 171   gdk_threads_enter ();
 172 }
 173
 174
 175
 176 JNIEXPORT void JNICALL
 177 Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_initState
 178   (JNIEnv *env, jobject obj)
 179 {
 180   GdkPixbufLoader *loader = NULL;
 181   jobject *decoder = NULL;
 182
 183   decoder = (jobject *) malloc (sizeof (jobject));
 184   g_assert (decoder != NULL);
 185   *decoder = (*env)->NewGlobalRef (env, obj);
 186
 187   gdk_threads_enter ();
 188   loader = gdk_pixbuf_loader_new ();
 189   g_assert (loader != NULL);
 190   g_signal_connect (loader, "area-prepared", G_CALLBACK (area_prepared), decoder);
 191   g_signal_connect (loader, "area-updated", G_CALLBACK (area_updated), decoder);
 192   g_signal_connect (loader, "closed", G_CALLBACK (closed), decoder);
 193   gdk_threads_leave ();
 194
 195   NSA_SET_PB_PTR (env, obj, loader);
 196 }
 197
 198 static void
 199 query_formats (JNIEnv *env, jclass clazz)
 200 {
 201   jobject jformat;
 202   GSList *formats, *f;
 203   GdkPixbufFormat *format;
 204   char **ch, *name;
 205
 206   jclass formatClass;
 207   jmethodID addExtensionID;
 208   jmethodID addMimeTypeID;
 209
 210   formatClass = (*env)->FindClass
 211     (env, "gnu/java/awt/peer/gtk/GdkPixbufDecoder$ImageFormatSpec");
 212
 213   g_assert(formatClass != NULL);
 214
 215   addExtensionID = (*env)->GetMethodID (env, formatClass,
 216                                         "addExtension",
 217                                         "(Ljava/lang/String;)V");
 218
 219   addMimeTypeID = (*env)->GetMethodID (env, formatClass,
 220                                        "addMimeType",
 221                                        "(Ljava/lang/String;)V");
 222
 223   formats = gdk_pixbuf_get_formats ();
 224
 225   for (f = formats; f; f = f->next)
 226     {
 227       format = (GdkPixbufFormat *) f->data;
 228       name = gdk_pixbuf_format_get_name(format);
 229
 230       jformat = (*env)->CallStaticObjectMethod
 231         (env, clazz, registerFormatID,
 232          (*env)->NewStringUTF(env, name),
 233          (jboolean) gdk_pixbuf_format_is_writable(format));
 234
 235       g_assert(jformat != NULL);
 236
 237       ch = gdk_pixbuf_format_get_extensions(format);
 238       while (*ch)
 239         {
 240           (*env)->CallVoidMethod (env, jformat, addExtensionID,
 241                                   (*env)->NewStringUTF(env, *ch));
 242           ++ch;
 243         }
 244
 245       ch = gdk_pixbuf_format_get_mime_types(format);
 246       while (*ch)
 247         {
 248           (*env)->CallVoidMethod (env, jformat, addMimeTypeID,
 249                                   (*env)->NewStringUTF(env, *ch));
 250           ++ch;
 251         }
 252     }
 253
 254   g_slist_free(formats);
 255 }
 256
 257
 258 JNIEXPORT void JNICALL
 259 Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_initStaticState
 260   (JNIEnv *env, jclass clazz)
 261 {
 262   jclass dataOutputClass;
 263
 264   (*env)->GetJavaVM(env, &vm);
 265
 266   areaPreparedID = (*env)->GetMethodID (env, clazz,
 267                                         "areaPrepared",
 268                                         "(II)V");
 269
 270   areaUpdatedID = (*env)->GetMethodID (env, clazz,
 271                                        "areaUpdated",
 272                                        "(IIII[II)V");
 273
 274   registerFormatID = (*env)->GetStaticMethodID
 275     (env, clazz,
 276      "registerFormat",
 277      "(Ljava/lang/String;Z)"
 278      "Lgnu/java/awt/peer/gtk/GdkPixbufDecoder$ImageFormatSpec;");
 279
 280
 281   dataOutputClass = (*env)->FindClass(env, "java/io/DataOutput");
 282   dataOutputWriteID = (*env)->GetMethodID (env, dataOutputClass,
 283                                              "write", "([B)V");
 284
 285   query_formats (env, clazz);
 286
 287   NSA_PB_INIT (env, clazz);
 288 }
 289
 290
 291 JNIEXPORT void JNICALL
 292 Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_finish
 293   (JNIEnv *env, jobject obj)
 294 {
 295   GdkPixbufLoader *loader = NULL;
 296
 297   loader = (GdkPixbufLoader *)NSA_DEL_PB_PTR (env, obj);
 298   if (loader == NULL)
 299     return;
 300
 301   gdk_threads_enter ();
 302   gdk_pixbuf_loader_close (loader, NULL);
 303   g_object_unref (loader);
 304   gdk_threads_leave ();
 305 }
 306
 307 struct stream_save_request
 308 {
 309   JNIEnv *env;
 310   jobject *stream;
 311 };
 312
 313 static gboolean
 314 save_to_stream(const gchar *buf,
 315                gsize count,
 316                GError **error __attribute__((unused)),
 317                gpointer data)
 318 {
 319   struct stream_save_request *ssr = (struct stream_save_request *)data;
 320
 321   jbyteArray jbuf;
 322   jbyte *cbuf;
 323
 324   gdk_threads_leave ();
 325   jbuf = (*(ssr->env))->NewByteArray ((ssr->env), count);
 326   cbuf = (*(ssr->env))->GetByteArrayElements ((ssr->env), jbuf, NULL);
 327   memcpy (cbuf, buf, count);
 328   (*(ssr->env))->ReleaseByteArrayElements ((ssr->env), jbuf, cbuf, 0);
 329   (*(ssr->env))->CallVoidMethod ((ssr->env), *(ssr->stream),
 330                                  dataOutputWriteID, jbuf);
 331   gdk_threads_enter ();
 332   return TRUE;
 333 }
 334
 335
 336 JNIEXPORT void JNICALL
 337 Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_streamImage
 338 (JNIEnv *env, jclass clazz __attribute__((unused)),
 339  jintArray jarr, jstring jenctype, jint width, jint height,
 340  jboolean hasAlpha, jobject stream)
 341 {
 342   GdkPixbuf* pixbuf;
 343   jint *ints;
 344   guchar a, r, g, b, *pix, *p;
 345   GError *err = NULL;
 346   const char *enctype;
 347   int i;
 348
 349   struct stream_save_request ssr;
 350   ssr.stream = &stream;
 351   ssr.env = env;
 352
 353   ints = (*env)->GetIntArrayElements (env, jarr, NULL);
 354   pix = g_malloc(width * height * (hasAlpha ? 4 : 3));
 355
 356   enctype = (*env)->GetStringUTFChars (env, jenctype, NULL);
 357   g_assert(enctype != NULL);
 358
 359   g_assert (pix != NULL);
 360   g_assert (ints != NULL);
 361
 362   p = pix;
 363   for (i = 0; i < width*height; ++i)
 364     {
 365       /*
 366        * Java encodes pixels as integers in a predictable arithmetic order:
 367        * 0xAARRGGBB. Since these are jints, JNI has already byte-swapped
 368        * them for us if necessary, so they're in "our" endianness, whatever
 369        * that is. It uses 4 bytes per pixel whether or not there's an alpha
 370        * channel.
 371        */
 372
 373       a = 0xff & (ints[i] >> 24);
 374       r = 0xff & (ints[i] >> 16);
 375       g = 0xff & (ints[i] >> 8);
 376       b = 0xff & ints[i];
 377
 378       /*
 379        * GDK-pixbuf has a very different storage model:
 380        *
 381        *  - A different alpha order (alpha after colors).
 382        *  - A different packing model (no alpha -> 3-bytes-per-pixel).
 383        *  - A different "RGB" order (host memory order, not endian-neutral).
 384        */
 385
 386       *p++ = r;
 387       *p++ = g;
 388       *p++ = b;
 389       if (hasAlpha)
 390         *p++ = a;
 391     }
 392
 393   gdk_threads_enter ();
 394   pixbuf =  gdk_pixbuf_new_from_data (pix,
 395                                       GDK_COLORSPACE_RGB,
 396                                       (gboolean) hasAlpha,
 397                                       8, width, height,
 398                                       width * (hasAlpha ? 4 : 3), /* rowstride */
 399                                       NULL, NULL);
 400   g_assert (pixbuf != NULL);
 401
 402   g_assert(gdk_pixbuf_save_to_callback (pixbuf,
 403                                         &save_to_stream,
 404                                         &ssr,
 405                                         enctype,
 406                                         &err, NULL));
 407
 408   g_object_unref (pixbuf);
 409
 410   gdk_threads_leave ();
 411   g_free(pix);
 412
 413   (*env)->ReleaseStringUTFChars (env, jenctype, enctype);
 414   (*env)->ReleaseIntArrayElements (env, jarr, ints, 0);
 415 }
 416
 417 JNIEXPORT void JNICALL
 418 Java_gnu_java_awt_peer_gtk_GdkPixbufDecoder_pumpBytes
 419   (JNIEnv *env, jobject obj, jbyteArray jarr, jint len)
 420 {
 421   GdkPixbufLoader *loader = NULL;
 422   jbyte *bytes = NULL;
 423
 424   if (len < 1)
 425     return;
 426
 427   bytes = (*env)->GetByteArrayElements (env, jarr, NULL);
 428   g_assert (bytes != NULL);
 429   loader = (GdkPixbufLoader *)NSA_GET_PB_PTR (env, obj);
 430   g_assert (loader != NULL);
 431
 432   gdk_threads_enter ();
 433   gdk_pixbuf_loader_write (loader, (const guchar *) bytes, len, NULL);
 434   gdk_threads_leave ();
 435
 436   (*env)->ReleaseByteArrayElements (env, jarr, bytes, 0);
 437 }