filter.c

Ming is a library for generating Macromedia Flash files (.swf), written in C, and includes useful ut

#include <stdlib.h>
#include <string.h>

#include "gradient.h"
#include "output.h"
#include "filter.h"
#include "error.h"

#include "libming.h"


struct Shadow_s
{
	float	angle;
	float	distance;
	float 	strength;
};


/*
 * create a new SWFShadow (contructor)
 * This Function creates a new SWFShadow object. Only useful for creating 
 * SWFFilter objects.
 */
SWFShadow 
newSWFShadow(float angle /* angle in radians */, 
             float distance /* distance in px*/, 
             float strength /* strength */)
{
	SWFShadow shadow = (SWFShadow)malloc(sizeof(struct Shadow_s));
	
	shadow->angle = angle;
	shadow->distance = distance;
	shadow->strength = strength;

	return shadow;
}

void destroySWFShadow(SWFShadow s)
{
	free(s);
}

struct Blur_s
{
	float 	blurX;
	float 	blurY;
	int 	passes;
};


/*
 * create a new SWFBlur
 * This function creates a new SWFBlur object. Only useful for creating
 * SWFFilter objects
 */
SWFBlur 
newSWFBlur(float blurX /* horiz. blur amount */, 
           float blurY /* vert. blur amount */, 
           int passes /* number of passes. shoub be <= 3 */)
{
	SWFBlur blur = (SWFBlur)malloc(sizeof(struct Blur_s));

	blur->blurX = blurX;
	blur->blurY = blurY;
	blur->passes = passes;

	return blur;
}

void destroySWFBlur(SWFBlur b)
{
	free(b);
}

struct BlurFilter
{
	SWFBlur blur;
};

struct DropShadowFilter
{
	SWFColor		color;	
	SWFBlur 		blur;
	SWFShadow		shadow;	
	int 			flags;
};

struct GlowFilter
{
	SWFColor	color;
	SWFBlur		blur;
	float 		strength;
	int 		flags;
};

struct BevelFilter
{
	SWFColor	shadowColor;
	SWFColor	highlightColor;
	SWFBlur		blur;
	SWFShadow	shadow;
	int 		flags;
};

struct GradientGlowFilter
{
	SWFGradient	gradient;
	SWFBlur		blur;	
	SWFShadow	shadow;
	int 		flags;	
};

struct GradientBevelFilter
{
	SWFGradient	gradient;
	SWFBlur	 	blur;
	SWFShadow	shadow;	
	int 		flags;
};


struct FilterMatrix_s
{
	int cols;
	int rows;
	float *values;
};

/*
 * create a new FilterMatrix (constructor)
 * This function creates a new SFWFilterMatrix. Only useful 
 * for creating SWFFilter objects.
 */
SWFFilterMatrix 
newSWFFilterMatrix(int cols /* number of cols */, 
                   int rows /* number of rows */, 
                   float *vals /* vals[cols * rows]. Will be copied */)
{
	SWFFilterMatrix matrix;

	if(cols <= 0 || rows <= 0)
		return NULL;
	
	matrix = (SWFFilterMatrix)malloc(sizeof(struct FilterMatrix_s));

	matrix->cols = cols;
	matrix->rows = rows;

	matrix->values = (float *)malloc(cols * rows * sizeof(float));
	memcpy(matrix->values, vals, cols * rows * sizeof(float));

	return matrix;
}

void destroySWFFilterMatrix(SWFFilterMatrix m)
{
	if(m == NULL)
		return;

	free(m->values);
	free(m);
}

struct ConvolutionFilter
{
	SWFFilterMatrix matrix;
	float 		divisor;
	float 		bias;
	SWFColor	color;
	int		flags;
};


struct ColorMatrixFilter
{
	SWFFilterMatrix matrix;
};

struct SWFFilter_s
{
	int id;
	union {
		struct DropShadowFilter 	dropShadow;
		struct BlurFilter		blur;
		struct GlowFilter		glow;
		struct BevelFilter		bevel;
		struct GradientGlowFilter	gradientGlow;
		struct ConvolutionFilter	convolution;
		struct ColorMatrixFilter	colorMatrix;
		struct GradientBevelFilter	gradientBevel;
	} filter;
};

static void writeDropShadowFilter(SWFOutput out, struct DropShadowFilter *filter)
{
	int flags = FILTER_MODE_COMPOSITE;

	SWFOutput_writeUInt8(out, filter->color.red);
	SWFOutput_writeUInt8(out, filter->color.green);
	SWFOutput_writeUInt8(out, filter->color.blue);
	SWFOutput_writeUInt8(out, filter->color.alpha);
	
	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	

	SWFOutput_writeFixed(out, filter->shadow->angle);
	SWFOutput_writeFixed(out, filter->shadow->distance);
	SWFOutput_writeFixed8(out, filter->shadow->strength);

	flags |= filter->flags;
	flags |= (0x1F & filter->blur->passes);
	SWFOutput_writeUInt8(out, flags);
}

static void writeBlurFilter(SWFOutput out, struct BlurFilter *filter)
{
	int flags = 0;

	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	

	flags = 0xff & (filter->blur->passes << 3);
	SWFOutput_writeUInt8(out, flags);
}

static void writeGlowFilter(SWFOutput out, struct GlowFilter *filter)
{
	int flags = FILTER_MODE_COMPOSITE;

	SWFOutput_writeUInt8(out, filter->color.red);
	SWFOutput_writeUInt8(out, filter->color.green);
	SWFOutput_writeUInt8(out, filter->color.blue);
	SWFOutput_writeUInt8(out, filter->color.alpha);

	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	

	SWFOutput_writeFixed8(out, filter->strength);
	flags |= filter->flags;
	flags |= (0x1F & filter->blur->passes);
	SWFOutput_writeUInt8(out, flags);
}

static void writeBevelFilter(SWFOutput out, struct BevelFilter *filter)
{
	int flags = FILTER_MODE_COMPOSITE;

	SWFOutput_writeUInt8(out, filter->shadowColor.red);
	SWFOutput_writeUInt8(out, filter->shadowColor.green);
	SWFOutput_writeUInt8(out, filter->shadowColor.blue);
	SWFOutput_writeUInt8(out, filter->shadowColor.alpha);

	SWFOutput_writeUInt8(out, filter->highlightColor.red);
	SWFOutput_writeUInt8(out, filter->highlightColor.green);
	SWFOutput_writeUInt8(out, filter->highlightColor.blue);
	SWFOutput_writeUInt8(out, filter->highlightColor.alpha);

	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	
	
	SWFOutput_writeFixed(out, filter->shadow->angle);
	SWFOutput_writeFixed(out, filter->shadow->distance);
	SWFOutput_writeFixed8(out, filter->shadow->strength);

	flags |= filter->flags;
	flags |= (0xF & filter->blur->passes);
	SWFOutput_writeUInt8(out, flags);
}

static void writeGradientGlowFilter(SWFOutput out, struct GradientGlowFilter *filter)
{
	int flags = FILTER_MODE_COMPOSITE;

	SWFOutput_writeGradientAsFilter(out, filter->gradient);
	
	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	
	
	SWFOutput_writeFixed(out, filter->shadow->angle);
	SWFOutput_writeFixed(out, filter->shadow->distance);
	SWFOutput_writeFixed8(out, filter->shadow->strength);

	flags |= filter->flags;
	flags |= (0xF & filter->blur->passes);
	SWFOutput_writeUInt8(out, flags);
}

static void writeConvolutionFilter(SWFOutput out, struct ConvolutionFilter *filter)
{
	int i;

	SWFOutput_writeUInt8(out, filter->matrix->cols);
	SWFOutput_writeUInt8(out, filter->matrix->rows);

	SWFOutput_writeFloat(out, filter->divisor);
	SWFOutput_writeFloat(out, filter->bias);

	for(i = 0; i < filter->matrix->cols * filter->matrix->rows; i++)
		SWFOutput_writeFloat(out, filter->matrix->values[i]);

	SWFOutput_writeUInt8(out, filter->color.red);
	SWFOutput_writeUInt8(out, filter->color.green);
	SWFOutput_writeUInt8(out, filter->color.blue);
	SWFOutput_writeUInt8(out, filter->color.alpha);

	SWFOutput_writeUInt8(out, filter->flags);
}

static void writeColorMatrixFilter(SWFOutput out, struct ColorMatrixFilter *filter)
{
	int i;

	for(i = 0; i < filter->matrix->rows * filter->matrix->cols; i++)
		SWFOutput_writeFloat(out, filter->matrix->values[i]);
}

static void writeGradientBevelFilter(SWFOutput out, struct GradientBevelFilter *filter)
{
	int flags = FILTER_MODE_COMPOSITE;

	SWFOutput_writeGradientAsFilter(out, filter->gradient);
	
	SWFOutput_writeFixed(out, filter->blur->blurX);
	SWFOutput_writeFixed(out, filter->blur->blurY);	
	
	SWFOutput_writeFixed(out, filter->shadow->angle);
	SWFOutput_writeFixed(out, filter->shadow->distance);
	SWFOutput_writeFixed8(out, filter->shadow->strength);

	flags |= filter->flags;
	flags |= (0xF & filter->blur->passes);
	SWFOutput_writeUInt8(out, flags);
}

void 
SWFOutput_writeSWFFilter(SWFOutput out, SWFFilter filter)
{
	if(out == NULL || filter == NULL)