/*
 * libopenraw - gdkpixbuf.c
 *
 * Copyright (C) 2006-2007 Hubert Figuiere
 *
 * 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, either version 3 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
 * 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, see
 * <http://www.gnu.org/licenses/>.
 */

/** @brief gdkpixbuf support */

#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <libopenraw/thumbnails.h>
#include <libopenraw/rawfile.h>
#include <libopenraw-gnome/gdkpixbuf.h>


static void pixbuf_free(guchar * data, gpointer u)
{
	(void)u;
	free(data);
}

/**
 * Returns a retained GdkPixbuf
 */
static GdkPixbuf *rotate_pixbuf(GdkPixbuf *tmp, int32_t orientation)
{
	GdkPixbuf *pixbuf = NULL;
	switch(orientation) {
	case 0:
	case 1:
		pixbuf = g_object_ref(tmp);
		break;
	case 2:
		pixbuf = gdk_pixbuf_flip(tmp, TRUE);
		break;
	case 3:
		pixbuf = gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
		break;
	case 4: {
		GdkPixbuf* rotated = gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
		pixbuf = gdk_pixbuf_flip(rotated, TRUE);
		g_object_unref(rotated);
		break;
	}
	case 5: {
		GdkPixbuf* rotated = gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_CLOCKWISE);
		pixbuf = gdk_pixbuf_flip(rotated, FALSE);
		g_object_unref(rotated);
		break;
	}
	case 6:
		pixbuf =  gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_CLOCKWISE);
		break;
	case 7: {
		GdkPixbuf* rotated = gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
		pixbuf = gdk_pixbuf_flip(rotated, FALSE);
		g_object_unref(rotated);
		break;
	}
	case 8:
		pixbuf =  gdk_pixbuf_rotate_simple(tmp, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
		break;		
	default:
		break;
	}
	return pixbuf;
}



static GdkPixbuf *_or_thumbnail_to_pixbuf(ORThumbnailRef thumbnail, 
										  int32_t orientation)
{
	GdkPixbuf* tmp = NULL;
	GdkPixbuf* pixbuf = NULL;
	
	const guchar * buf;
	or_data_type format = or_thumbnail_format(thumbnail);
	buf = (const guchar *)or_thumbnail_data(thumbnail);
	
	switch (format)
	{
	case OR_DATA_TYPE_PIXMAP_8RGB:
	{
		uint32_t x, y;
		size_t buf_size;
		guchar * data;

		buf_size = or_thumbnail_data_size(thumbnail);
		data = (guchar*)malloc(buf_size);
		memcpy(data, buf, buf_size);
		or_thumbnail_dimensions(thumbnail, &x, &y);
		
		tmp = gdk_pixbuf_new_from_data(data, 
					       GDK_COLORSPACE_RGB,
					       FALSE, 8, x, y, x * 3, 
					       pixbuf_free, NULL);
		break;
	}
	case OR_DATA_TYPE_JPEG:
	case OR_DATA_TYPE_TIFF:
	case OR_DATA_TYPE_PNG:
	{
		GdkPixbufLoader *loader = NULL;
		size_t count = or_thumbnail_data_size(thumbnail);
		loader = gdk_pixbuf_loader_new();
		if (loader != NULL) {
			GError* error = NULL;
			if(!gdk_pixbuf_loader_write(loader, buf,
						    count, &error) && error) {
				fprintf(stderr, "loader write error: %s",
					error->message);
				g_error_free(error);
				error = NULL;
			}
			if(!gdk_pixbuf_loader_close(loader, &error) && error) {
				fprintf(stderr, "loader close error: %s",
					error->message);
				g_error_free(error);
			}
			tmp = gdk_pixbuf_loader_get_pixbuf(loader);
			g_object_ref(tmp);
			g_object_unref(loader);
		}
		break;
	}
	default: 
		break;
	}
	pixbuf = rotate_pixbuf(tmp, orientation);
	g_object_unref(tmp);
	return pixbuf;
}




GdkPixbuf *or_thumbnail_to_pixbuf(ORThumbnailRef thumbnail)
{
	return _or_thumbnail_to_pixbuf(thumbnail, 0); 
}


static GdkPixbuf *_or_gdkpixbuf_extract_thumbnail(const char *path, 
						  uint32_t preferred_size, 
						  gboolean rotate)
{
	ORRawFileRef rf;
	int32_t orientation = 0;
	GdkPixbuf *pixbuf = NULL;
	or_error err = OR_ERROR_NONE;
	ORThumbnailRef thumbnail = NULL;

	rf = or_rawfile_new(path, OR_RAWFILE_TYPE_UNKNOWN);
	if(rf) {
		if(rotate) {
			orientation = or_rawfile_get_orientation(rf);
		}
		thumbnail = or_thumbnail_new();
		err = or_rawfile_get_thumbnail(rf, preferred_size,
									   thumbnail);
		if (err == OR_ERROR_NONE)	{
			pixbuf = _or_thumbnail_to_pixbuf(thumbnail, orientation);
		}
		else {
			g_debug("or_get_extract_thumbnail() failed with %d.", err);
		}
		err = or_thumbnail_release(thumbnail);
		if (err != OR_ERROR_NONE) {
			g_warning("or_thumbnail_release() failed with %d", err);
		}
		or_rawfile_release(rf);
	}

	return pixbuf;
}



GdkPixbuf *or_gdkpixbuf_extract_thumbnail(const char *path, uint32_t preferred_size)
{
	return _or_gdkpixbuf_extract_thumbnail(path, preferred_size, FALSE);
}

GdkPixbuf *or_gdkpixbuf_extract_rotated_thumbnail(const char *path, uint32_t preferred_size)
{
	return _or_gdkpixbuf_extract_thumbnail(path, preferred_size, TRUE);
}