git.zarb.org Git - booh/blob - ext/rbbooh.c

   1 /*
   2  *                         *  BOOH  *
   3  *
   4  * A.k.a `Best web-album Of the world, Or your money back, Humerus'.
   5  *
   6  * The acronyn sucks, however this is a tribute to Dragon Ball by
   7  * Akira Toriyama, where the last enemy beaten by heroes of Dragon
   8  * Ball is named "Boo". But there was already a free software project
   9  * called Boo, so this one will be it "Booh". Or whatever.
  10  *
  11  *
  12  * Copyright (c) 2005 Guillaume Cottenceau
  13  *
  14  * This software may be freely redistributed under the terms of the GNU
  15  * public license version 2.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  */
  22
  23 #include <math.h>
  24
  25 #include <exiv2/image.hpp>
  26 #include <exiv2/exif.hpp>
  27
  28 #define GDK_PIXBUF_ENABLE_BACKEND
  29 #include <gtk/gtk.h>
  30 #include "rbgobject.h"
  31
  32 #define _SELF(s) GDK_PIXBUF(RVAL2GOBJ(s))
  33
  34 static VALUE whitebalance(VALUE self, VALUE level) {
  35         double red_filter[256], blue_filter[256];
  36         int i, x, y;
  37         guchar* pixels = gdk_pixbuf_get_pixels(_SELF(self));
  38         int rowstride = gdk_pixbuf_get_rowstride(_SELF(self));
  39
  40         double factor = 1 + fabs(NUM2DBL(level))/100;
  41         if (NUM2DBL(level) < 0) {
  42                 factor = 1/factor;
  43         }
  44
  45         for (i = 0; i < 256; i++) {
  46                 red_filter[i]  = pow(((double)i)/255, 1/factor) * 255;
  47                 blue_filter[i] = pow(((double)i)/255, factor) * 255;
  48         }
  49
  50         for (y = 0; y < gdk_pixbuf_get_height(_SELF(self)); y++) {
  51                 guchar* pixline = &(pixels[rowstride*y]);
  52                 for (x = 0; x < gdk_pixbuf_get_width(_SELF(self)); x++) {
  53                         pixline[x*3]   = red_filter[pixline[x*3]];
  54                         pixline[x*3+2] = blue_filter[pixline[x*3+2]];
  55                 }
  56         }
  57
  58         return self;
  59 }
  60
  61 static VALUE gammacorrect(VALUE self, VALUE level) {
  62         double filter[256];
  63         int i, x, y;
  64         guchar* pixels = gdk_pixbuf_get_pixels(_SELF(self));
  65         int rowstride = gdk_pixbuf_get_rowstride(_SELF(self));
  66
  67         double factor = 1 + fabs(NUM2DBL(level))/100;
  68         if (NUM2DBL(level) > 0) {
  69                 factor = 1/factor;
  70         }
  71
  72         for (i = 0; i < 256; i++) {
  73                 filter[i] = pow(((double)i)/255, factor) * 255;
  74         }
  75
  76         for (y = 0; y < gdk_pixbuf_get_height(_SELF(self)); y++) {
  77                 guchar* pixline = &(pixels[rowstride*y]);
  78                 for (x = 0; x < gdk_pixbuf_get_width(_SELF(self)); x++) {
  79                         pixline[x*3]   = filter[pixline[x*3]];
  80                         pixline[x*3+1] = filter[pixline[x*3+1]];
  81                         pixline[x*3+2] = filter[pixline[x*3+2]];
  82                 }
  83         }
  84
  85         return self;
  86 }
  87
  88 static VALUE exif_orientation(VALUE module, VALUE filename) {
  89         try {
  90                 Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(StringValuePtr(filename));
  91                 image->readMetadata();
  92                 Exiv2::ExifData &exifData = image->exifData();
  93                 if (exifData.empty()) {
  94                         return Qnil;
  95                 }
  96                 Exiv2::ExifData::const_iterator i = exifData.findKey(Exiv2::ExifKey("Exif.Image.Orientation"));
  97                 if (i != exifData.end()) {
  98                         return INT2NUM(i->value().toLong());
  99                 }
 100                 return Qnil;
 101         } catch (Exiv2::AnyError& e) {
 102                 std::cout << "Caught Exiv2 exception: " << e << "\n";
 103                 return Qnil;
 104         }
 105 }
 106
 107 static VALUE exif_set_orientation(VALUE module, VALUE filename, VALUE val) {
 108         try {
 109                 Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(StringValuePtr(filename));
 110                 image->readMetadata();
 111                 Exiv2::ExifData &exifData = image->exifData();
 112                 exifData["Exif.Image.Orientation"] = uint16_t(NUM2INT(val));
 113                 image->writeMetadata();
 114         } catch (Exiv2::AnyError& e) {
 115                 std::cout << "Caught Exiv2 exception: " << e << "\n";
 116         }
 117         return Qnil;
 118 }
 119
 120 static VALUE exif_datetimeoriginal(VALUE module, VALUE filename) {
 121         try {
 122                 Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(StringValuePtr(filename));
 123                 image->readMetadata();
 124                 Exiv2::ExifData &exifData = image->exifData();
 125                 if (exifData.empty()) {
 126                         return Qnil;
 127                 }
 128                 Exiv2::ExifData::const_iterator i = exifData.findKey(Exiv2::ExifKey("Exif.Photo.DateTimeOriginal"));
 129                 if (i != exifData.end()) {
 130                         return rb_str_new2(i->value().toString().c_str());
 131                 }
 132                 return Qnil;
 133         } catch (Exiv2::AnyError& e) {
 134                 std::cout << "Caught Exiv2 exception: " << e << "\n";
 135                 return Qnil;
 136         }
 137 }
 138
 139 // internalize drawing "video" borders, it is too slow in ruby (0.12 secs on my p4 2.8 GHz, whereas it's barely measurable with this implementation)
 140 static VALUE draw_borders(VALUE self, VALUE pixbuf, VALUE x1, VALUE x2, VALUE ystart, VALUE yend) {
 141         GdkDrawable* drawable = GDK_DRAWABLE(RVAL2GOBJ(self));
 142         int y = NUM2INT(ystart);
 143         int yend_ = NUM2INT(yend);
 144         GdkPixbuf* pb = GDK_PIXBUF(RVAL2GOBJ(pixbuf));
 145         int height = gdk_pixbuf_get_height(pb);
 146         while (y < yend_) {
 147                 int render_height = MIN(height, yend_ - y);
 148                 gdk_draw_pixbuf(drawable, NULL, pb, 0, 0, NUM2INT(x1), y, -1, render_height, GDK_RGB_DITHER_NONE, -1, -1);
 149                 gdk_draw_pixbuf(drawable, NULL, pb, 0, 0, NUM2INT(x2), y, -1, render_height, GDK_RGB_DITHER_NONE, -1, -1);
 150                 y += height;
 151         }
 152         return self;
 153 }
 154
 155 // internalize memory leak fix for GdkPixbuf.rotate
 156 // (bugged as of rg2 0.16.0)
 157 static VALUE rotate_noleak(VALUE self, VALUE angle) {
 158         VALUE ret;
 159         GdkPixbuf* dest = gdk_pixbuf_rotate_simple(_SELF(self), (GdkPixbufRotation) RVAL2GENUM(angle, GDK_TYPE_PIXBUF_ROTATION));
 160         if (dest == NULL)
 161                 return Qnil;
 162         ret = GOBJ2RVAL(dest);
 163         g_object_unref(dest);
 164         return ret;
 165 }
 166
 167 // internalize allowing to pass Qnil to RVAL2BOXED to have NULL passed to Gtk
 168 // (bugged as of rg2 0.16.0)
 169 static VALUE modify_bg(VALUE self, VALUE state, VALUE color) {
 170         gtk_widget_modify_bg(GTK_WIDGET(RVAL2GOBJ(self)), (GtkStateType) RVAL2GENUM(state, GTK_TYPE_STATE_TYPE),
 171                              NIL_P(color) ? NULL : (GdkColor*) RVAL2BOXED(color, GDK_TYPE_COLOR));
 172         return self;
 173 }
 174
 175 extern "C" {
 176 void
 177 Init_libadds()
 178 {
 179     RGObjClassInfo* cinfo = (RGObjClassInfo*)rbgobj_lookup_class_by_gtype(GDK_TYPE_PIXBUF, Qnil);
 180     rb_define_method(cinfo->klass, "whitebalance!", (VALUE (*)(...)) whitebalance, 1);
 181     rb_define_method(cinfo->klass, "gammacorrect!", (VALUE (*)(...)) gammacorrect, 1);
 182     rb_define_method(cinfo->klass, "rotate", (VALUE (*)(...)) rotate_noleak, 1);
 183
 184     cinfo = (RGObjClassInfo*)rbgobj_lookup_class_by_gtype(GDK_TYPE_DRAWABLE, Qnil);
 185     rb_define_method(cinfo->klass, "draw_borders", (VALUE (*)(...)) draw_borders, 5);
 186
 187     cinfo = (RGObjClassInfo*)rbgobj_lookup_class_by_gtype(GTK_TYPE_WIDGET, Qnil);
 188     rb_define_method(cinfo->klass, "modify_bg", (VALUE (*)(...)) modify_bg, 2);
 189
 190     VALUE exif = rb_define_module("Exif");
 191     rb_define_module_function(exif, "orientation", (VALUE (*)(...)) exif_orientation, 1);
 192     rb_define_module_function(exif, "set_orientation", (VALUE (*)(...)) exif_set_orientation, 2);
 193     rb_define_module_function(exif, "datetimeoriginal", (VALUE (*)(...)) exif_datetimeoriginal, 1);
 194 }
 195 }