filter.c

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

		return;

	SWFOutput_writeUInt8(out, filter->id);
	switch(filter->id)
	{
		case SWFFILTER_TYPE_DROPSHADOW:
			writeDropShadowFilter(out, &filter->filter.dropShadow);
			break;
		case SWFFILTER_TYPE_BLUR:
			writeBlurFilter(out, &filter->filter.blur);
			break;
		case SWFFILTER_TYPE_GLOW:
			writeGlowFilter(out, &filter->filter.glow);
			break;
		case SWFFILTER_TYPE_BEVEL:
			writeBevelFilter(out, &filter->filter.bevel);
			break;
		case SWFFILTER_TYPE_GRADIENTGLOW:
			writeGradientGlowFilter(out, &filter->filter.gradientGlow);
			break;
		case SWFFILTER_TYPE_CONVOLUTION:
			writeConvolutionFilter(out, &filter->filter.convolution);
			break;
		case SWFFILTER_TYPE_COLORMATRIX:
			writeColorMatrixFilter(out, &filter->filter.colorMatrix);
			break;
		case SWFFILTER_TYPE_GRADIENTBEVEL:
			writeGradientBevelFilter(out, &filter->filter.gradientBevel);
			break;
		default:
			SWF_error("destroySWFFilter: invalid filter\n");
	}
	
}

void 
destroySWFFilter(SWFFilter filter)
{
	if(filter == NULL)
		return;

	switch(filter->id)
	{
		case SWFFILTER_TYPE_DROPSHADOW:
			// destroyDropShadowFilter(&filter->filter.dropShadow);
			break;
		case SWFFILTER_TYPE_BLUR:
			// destroyBlurFilter(&filter->filter.blur);
			break;
		case SWFFILTER_TYPE_GLOW:
			// destroyGlowFilter(&filter->filter.glow);
			break;
		case SWFFILTER_TYPE_BEVEL:
			//destroyBevelFilter(&filter->filter.bevel);
			break;
		case SWFFILTER_TYPE_GRADIENTGLOW:
			// destroyGradientGlowFilter(&filter->filter.gradientGlow);
			break;
		case SWFFILTER_TYPE_CONVOLUTION:
			// destroyConvolutionFilter(&filter->filter.convolution);
			break;
		case SWFFILTER_TYPE_COLORMATRIX:
			// destroyColorMatrixFilter(&filter->filter.colorMatrix);
			break;
		case SWFFILTER_TYPE_GRADIENTBEVEL:
			// destroyGradientBevelFilter(&filter->filter.gradientBevel);
			break;
		default:
			SWF_error("destroySWFFilter: invalid filter\n");
	}
	free(filter);
}

/* 
 * creates a new ColormatrixFilter 
 * Matrix has to be 5 x 4
 * [r0 ... r4]
 * [g0 ... g4]
 * [b0 ... b4]
 * [a0 ... a4]
 */
SWFFilter
newColorMatrixFilter(SWFFilterMatrix matrix /* matrix */)
{
	SWFFilter filter;

	if(matrix == NULL)
		return NULL;

	if(matrix->rows != 4 || matrix->cols != 5)
	{
		SWF_warn("newColorMatrixFilter: color matrix has to be 5x4\n");
		return NULL;
	}	

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_COLORMATRIX;

	filter->filter.colorMatrix.matrix = matrix;

	return filter;
}

/*
 * creates a new ConvolutionFilter
 */
SWFFilter 
newConvolutionFilter(SWFFilterMatrix matrix /* matrix */, 
                     float divisor /* divisor applied to matrix */,
                     float bias /* matrix bias */,
                     SWFColor color /* default color */,
                     int flags /* FILTER_FLAG_CLAMP , FILTER_FLAG_PRESERVE_ALPHA */)
{
	SWFFilter filter;
	struct ConvolutionFilter *convolution;

	if(matrix == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_CONVOLUTION;

	convolution = &filter->filter.convolution;

	convolution->matrix = matrix;
	convolution->divisor = divisor;
	convolution->bias = bias;
	convolution->color = color;
	convolution->flags = flags;

	return filter;
}
                     


/*
 * create a GradientBevelFilter 
 * This functions creates a gradient bevel filter. Extends BevelFilter by
 * using a gradient instead of a simple color
 */
SWFFilter
newGradientBevelFilter(SWFGradient gradient /* gradient */, 
                       SWFBlur blur /* blur */,
                       SWFShadow shadow /* shadow */,
                       int flags /* FILTER_MODE_INNER,  FILTER_MODE_KO, FILTER_MODE_ONTOP */)
{
	SWFFilter filter;
	struct GradientBevelFilter *gBevel;
	
	if(gradient == NULL || blur == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_GRADIENTBEVEL;

	gBevel = &filter->filter.gradientBevel;

	gBevel->gradient = gradient;
	gBevel->blur = blur;
	gBevel->shadow = shadow;
	gBevel->flags = flags;

	return filter;
} 

/* 
 * creates a GardientGlowFilter
 * This functions creates a gradient glow filter. Extends GlowFilter by
 * using a gradient instead of a simple color
 */
SWFFilter 
newGradientGlowFilter(SWFGradient gradient /* gradient */, 
                      SWFBlur blur /* blur */, 
                      SWFShadow shadow /* shadow */,
                      int flags /* FILTER_MODE_INNER,  FILTER_MODE_KO, FILTER_MODE_ONTOP */)
{
	SWFFilter filter;
	struct GradientGlowFilter *gGlow;

	if(gradient == NULL || blur == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_GRADIENTGLOW;

	gGlow = &filter->filter.gradientGlow;

	gGlow->gradient = gradient;
	gGlow->blur = blur;
	gGlow->shadow = shadow;
	gGlow->flags = flags;

	return filter;
}

/* 
 * creates a BevelFilter
 * This functions creates a bevel filter. Creates a smooth bevel
 */
SWFFilter 
newBevelFilter(SWFColor shadowColor /* shadow color */, 
               SWFColor highlightColor /* highlight color */, 
               SWFBlur blur /* blur */, 
               SWFShadow shadow /* shadow */,
               int flags /* FILTER_MODE_INNER,  FILTER_MODE_KO, FILTER_MODE_ONTOP */)
{
	SWFFilter filter;
	struct BevelFilter *bevel;

	if(blur == NULL || shadow == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_BEVEL;

	bevel = &filter->filter.bevel;

	bevel->shadowColor = shadowColor;
	bevel->highlightColor = highlightColor;
	bevel->blur = blur; 
	bevel->shadow = shadow;
	bevel->flags = flags;

	return filter;
}

/* 
 * creates a GlowFilter
 * This functions creates a glow filter.
 */
SWFFilter 
newGlowFilter(SWFColor color /* color of shadow */, 
              SWFBlur blur /* blur */, 
              float strength /* strength */, 
              int flags /* FILTER_MODE_INNER,  FILTER_MODE_KO */)
{
	SWFFilter filter;
	struct GlowFilter *glow;
	
	if(blur == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_GLOW;

	glow = &filter->filter.glow;

	glow->color = color;
	glow->blur = blur;
	glow->strength = strength;
	glow->flags = flags;

	return filter;
}

/*
 * creates a BlurFilter 
 * This functions creates a blur filter.
 */
SWFFilter 
newBlurFilter(SWFBlur blur /* blur */)
{
	SWFFilter filter;
	struct BlurFilter *b;
	if(blur == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_BLUR;
	b = &filter->filter.blur;
	b->blur = blur;

	return filter;
}

/*
 * creates a DropShadowFilter 
 * This functions creates a drop shadow filter filter.
 */
SWFFilter 
newDropShadowFilter(SWFColor color /* color of shadow */, 
                    SWFBlur blur /* blur */, 
                    SWFShadow shadow /* shadow */, 
                    int flags /* FILTER_MODE_INNER,  FILTER_MODE_KO */)
{
	struct DropShadowFilter *dropShadow;
	SWFFilter filter;

	if(blur == NULL || shadow == NULL)
		return NULL;

	filter = (SWFFilter)malloc(sizeof(struct SWFFilter_s));
	filter->id = SWFFILTER_TYPE_DROPSHADOW;

	dropShadow = &filter->filter.dropShadow;
	dropShadow->color = color;
	dropShadow->blur = blur;
	dropShadow->shadow = shadow;
	dropShadow->flags = flags;

	return filter;
}

SWFFilterList newSWFFilterList()
{
	SWFFilterList list;

	list = (SWFFilterList)malloc(sizeof(struct SWFFilterList_s));
        list->numFilter = 0;
        list->filter = NULL;
	return list;
}

void SWFFilterList_add(SWFFilterList list, SWFFilter filter)
{
	int count = list->numFilter;
        list->filter = (SWFFilter*)realloc(list->filter, (count + 1) * sizeof(SWFFilter));
        list->filter[count] = filter;
        list->numFilter++;
}

void SWFOutput_writeFilterList(SWFOutput out, SWFFilterList list)
{
	int i;
	if(list->numFilter <= 0)
		return;

	SWFOutput_writeUInt8(out, list->numFilter);
	for(i = 0; i < list->numFilter; i++)
		SWFOutput_writeSWFFilter(out, list->filter[i]);
}

void destroySWFFilterList(SWFFilterList list)
{
	free(list->filter);
	free(list);
}