/*
 * transition_affine.c -- affine transformations
 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
 * Author: Charles Yates <charles.yates@pandora.be>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "transition_affine.h"
#include <framework/mlt.h>

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h>

typedef struct 
{
	float matrix[3][3];
}
affine_t;

static void affine_init( float this[3][3] )
{
	this[0][0] = 1;
	this[0][1] = 0;
	this[0][2] = 0;
	this[1][0] = 0;
	this[1][1] = 1;
	this[1][2] = 0;
	this[2][0] = 0;
	this[2][1] = 0;
	this[2][2] = 1;
}

// Multiply two this affine transform with that
static void affine_multiply( float this[3][3], float that[3][3] )
{
	float output[3][3];
	int i;
	int j;

	for ( i = 0; i < 3; i ++ )
		for ( j = 0; j < 3; j ++ )
			output[i][j] = this[i][0] * that[j][0] + this[i][1] * that[j][1] + this[i][2] * that[j][2];

	this[0][0] = output[0][0];
	this[0][1] = output[0][1];
	this[0][2] = output[0][2];
	this[1][0] = output[1][0];
	this[1][1] = output[1][1];
	this[1][2] = output[1][2];
	this[2][0] = output[2][0];
	this[2][1] = output[2][1];
	this[2][2] = output[2][2];
}

// Rotate by a given angle
static void affine_rotate( float this[3][3], float angle )
{
	float affine[3][3];
	affine[0][0] = cos( angle * M_PI / 180 );
	affine[0][1] = 0 - sin( angle * M_PI / 180 );
	affine[0][2] = 0;
	affine[1][0] = sin( angle * M_PI / 180 );
	affine[1][1] = cos( angle * M_PI / 180 );
	affine[1][2] = 0;
	affine[2][0] = 0;
	affine[2][1] = 0;
	affine[2][2] = 1;
	affine_multiply( this, affine );
}

static void affine_scale( float this[3][3], float sx, float sy )
{
	float affine[3][3];
	affine[0][0] = sx;
	affine[0][1] = 0;
	affine[0][2] = 0;
	affine[1][0] = 0;
	affine[1][1] = sy;
	affine[1][2] = 0;
	affine[2][0] = 0;
	affine[2][1] = 0;
	affine[2][2] = 1;
	affine_multiply( this, affine );
}

// Shear by a given value
static void affine_shear( float this[3][3], float shear )
{
	float affine[3][3];
	affine[0][0] = 1;
	affine[0][1] = shear;
	affine[0][2] = 0;
	affine[1][0] = 0;
	affine[1][1] = 1;
	affine[1][2] = 0;
	affine[2][0] = 0;
	affine[2][1] = 0;
	affine[2][2] = 1;
	affine_multiply( this, affine );
}

// Shear by a given value
static void affine_invert( float this[3][3] )
{
	float affine[3][3];
	affine[0][0] = 1;
	affine[0][1] = -1;
	affine[0][2] = 0;
	affine[1][0] = -1;
	affine[1][1] = 1;
	affine[1][2] = 0;
	affine[2][0] = 0;
	affine[2][1] = 0;
	affine[2][2] = 1;
	affine_multiply( this, affine );
}

static void affine_offset( float this[3][3], int x, int y )
{
	this[0][2] += x;
	this[1][2] += y;
}

// Obtain the mapped x coordinate of the input
static inline float MapX( float this[3][3], int x, int y )
{
	return this[0][0] * x + this[0][1] * y + this[0][2] + 0.5;
}

// Obtain the mapped y coordinate of the input
static inline float MapY( float this[3][3], int x, int y )
{
	return this[1][0] * x + this[1][1] * y + this[1][2] + 0.5;
}

/** Get the image.
*/

static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
	// Get the b frame from the stack
	mlt_frame b_frame = mlt_frame_pop_frame( a_frame );

	// Get the transition object
	mlt_transition transition = mlt_frame_pop_service( a_frame );

	// Get the properties of the transition
	mlt_properties properties = mlt_transition_properties( transition );

	// Get the properties of the a frame
	//mlt_properties a_props = mlt_frame_properties( a_frame );

	// Get the properties of the b frame
	//mlt_properties b_props = mlt_frame_properties( b_frame );

	// Image, format, width, height and image for the b frame
	uint8_t *b_image = NULL;
	mlt_image_format b_format = mlt_image_yuv422;
	int b_width;
	int b_height;

	// Fetch the a frame image
	mlt_frame_get_image( a_frame, image, format, width, height, 1 );

	// Fetch the b frame image
	b_width = *width;
	b_height = *height;
	mlt_properties_set( mlt_frame_properties( b_frame ), "rescale.interp", "nearest" );
	mlt_properties_set( mlt_frame_properties( b_frame ), "distort", "true" );
	mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );

	// Check that both images are of the correct format and process
	if ( *format == mlt_image_yuv422 && b_format == mlt_image_yuv422 )
	{
		int x, y;
		int dx, dy;

		// This is the matrix we're creating
		affine_t *affine = mlt_properties_get_data( properties, "affine", NULL );

		// Get values from the transition
		char *geometry = mlt_properties_get( properties, "geometry" );
		float rotate = mlt_properties_get_double( properties, "rotate" );
		float shear = mlt_properties_get_double( properties, "shear" );
		int invert = mlt_properties_get_int( properties, "invert" );
		float sx = mlt_properties_get_double( properties, "sx" );
		float sy = mlt_properties_get_double( properties, "sy" );
		float ox = mlt_properties_get_double( properties, "ox" );
		float oy = mlt_properties_get_double( properties, "oy" );

		// Geometry
		float gx = 0;
		float gy = 0;
		float gw = *width;
		float gh = *height;

		uint8_t *p = *image;
		//uint8_t *luma = mlt_properties_get_data( b_props, "luma", NULL );

		// Constructuct the matrix
		if ( rotate != 0 )
			affine_rotate( affine->matrix, rotate );
		if ( shear != 0 )
			affine_shear( affine->matrix, shear );

		affine_scale( affine->matrix, sx, sy );
		affine_offset( affine->matrix, ox, oy );
		if ( invert )
			affine_invert( affine->matrix );

		if ( geometry != NULL )
		{
			sscanf( geometry, "%f,%f:%fx%f", &gx, &gy, &gw, &gh );
			gx = gx / 100 * *width;
			gy = gy / 100 * *height;
			gw = gw / 100 * *width;
			gh = gh / 100 * *height;
		}

		for ( y = - *height / 2; y < *height / 2; y ++ )
		{
			for ( x = - *width / 2; x < *width / 2; x ++ )
			{
				dx = MapX( affine->matrix, x, y ) + b_width / 2;
				dy = MapY( affine->matrix, x, y ) + b_height / 2;

				if ( dx >= 0 && dx < b_width && dy >=0 && dy < b_height )
				{
					*p ++ = *( b_image + dy * b_width * 2 + dx * 2 );
					if ( x % 2 == 0 )
						*p ++ = *( b_image + dy * b_width * 2 + ( dx / 2 ) * 4 + 1 );
					else
						*p ++ = *( b_image + dy * b_width * 2 + ( dx / 2 ) * 4 + 3 );
				}
				else
				{
					p += 2;
				}
			}
		}
	}

	return 0;
}

/** Affine transition processing.
*/

static mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
	// Get a unique name to store the frame position
	char *name = mlt_properties_get( mlt_transition_properties( transition ), "_unique_id" );

	// Assign the current position to the name
	mlt_properties_set_position( mlt_frame_properties( a_frame ), name, mlt_frame_get_position( a_frame ) );

	// Push the transition on to the frame
	mlt_frame_push_service( a_frame, transition );

	// Push the b_frame on to the stack
	mlt_frame_push_frame( a_frame, b_frame );

	// Push the transition method
	mlt_frame_push_get_image( a_frame, transition_get_image );
	
	return a_frame;
}

/** Constructor for the filter.
*/

mlt_transition transition_affine_init( char *arg )
{
	mlt_transition transition = mlt_transition_new( );
	if ( transition != NULL )
	{
		affine_t *affine = malloc( sizeof( affine_t ) );
		affine_init( affine->matrix );
		mlt_properties_set_data( mlt_transition_properties( transition ), "affine", affine, 0, free, NULL );
		mlt_properties_set_int( mlt_transition_properties( transition ), "sx", 1 );
		mlt_properties_set_int( mlt_transition_properties( transition ), "sy", 1 );
		mlt_properties_set( mlt_transition_properties( transition ), "geometry", "0,0:100%x100%" );
		transition->process = transition_process;
	}
	return transition;
}