X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=src%2Fswfc-history.c;h=0d744631d8b053d20d618ddc000617cee0417b9d;hb=d8071bf754f070a660ac49108bd35d1900301066;hp=b7ce3996a62dc89b035f003ab5b07bfbe00bbebb;hpb=3ef17c4cee41231e1eed731c08381d3ddf0c8d1a;p=swftools.git

diff --git a/src/swfc-history.c b/src/swfc-history.c
index b7ce399..0d74463 100644
--- a/src/swfc-history.c
+++ b/src/swfc-history.c
@@ -21,7 +21,7 @@
 
 #include <stdlib.h>
 #include <memory.h>
-#include "history.h"
+#include "swfc-history.h"
 
 change_t* change_new(U16 frame, int function, float value, interpolation_t* inter)
 {
@@ -48,12 +48,65 @@ void change_init(change_t* change)
 
 void change_append(change_t* first, change_t* newChange)
 {
+    change_t* previous = 0;
+    change_t* start = first;
+    float p0, p1, m0, m1;
+
 	while (first->next)
+    {
+    	previous = first;
 		first = first->next;
+    }
 	first->next = newChange;
+    if (first->function == CF_QCHANGE)
+    {
+    	p0 = previous->value;
+    	p1 = first->value;
+    	if (previous->function == CF_QCHANGE)
+    	    m0 = (3 * previous->spline.a + 2 * previous->spline.b + previous->spline.c);
+    	else
+    	    if (previous->function == CF_CHANGE)
+    	    	m0 = (change_value(start, previous->frame) - change_value(start, previous->frame - 1)) * (first->frame - previous->frame);
+    	    else
+    		m0 = (first->value - previous->value);
+    	if (newChange->function == CF_QCHANGE)
+    	    m1 = 0.5 * (newChange->value - previous->value);
+    	else
+    	    if (newChange->function == CF_CHANGE)
+    		m1 = (change_value(previous, first->frame + 1) - change_value(previous, first->frame)) * (first->frame - previous->frame);
+    	    else
+  		m1 = (first->value - previous->value);
+    	first->spline.a = 2 * p0 + m0 - 2 * p1 + m1;
+    	first->spline.b = -3 * p0 - 2 * m0 + 3 * p1 - m1;
+    	first->spline.c = m0;
+    	first->spline.d = p0;
+    }
+    if (newChange->function == CF_QCHANGE)
+    {
+    	p0 = first->value;
+    	p1 = newChange->value;
+    	if (first->function == CF_QCHANGE)
+    	    m0 = m1;
+    	else
+    	    if (first->function == CF_CHANGE)
+    	    	m0 = (change_value(start, first->frame) - change_value(start, first->frame - 1)) * (first->frame - previous->frame);
+    	    else
+	    	m0 = (newChange->value - first->value);
+    	m1 = (newChange->value - first->value);
+    	newChange->spline.a = 2 * p0 + m0 - 2 * p1 + m1;
+    	newChange->spline.b = -3 * p0 - 2 * m0 + 3 * p1 - m1;
+    	newChange->spline.c = m0;
+    	newChange->spline.d = p0;
+    }
+}
+
+float calculateSpline(change_t* modification, float fraction)
+{
+    spline_t s = modification->spline;
+    return (((s.a * fraction) + s.b) * fraction + s.c) * fraction + s.d;
 }
 
-float interpolateParameter(float p1, float p2, float fraction, interpolation_t* inter)
+float interpolateScalar(float p1, float p2, float fraction, interpolation_t* inter)
 {
 	if (!inter)
 		return linear(fraction, p1, p2 - p1);
@@ -97,35 +150,54 @@ float interpolateParameter(float p1, float p2, float fraction, interpolation_t*
 	}
 }
 
-float change_value(change_t* first, U16 frame)
+int change_differs(change_t* modification, U16 frame)
 {
-	change_t* previous = first;
-	while (first && first->frame < frame)
+    change_t* previous = modification;
+    while (modification && modification->frame < frame)
 	{
-		previous = first;
-		first = first->next;
+	previous = modification;
+	modification = modification->next;
+    }
+    if (!modification)
+	return 0;
+    if (modification->frame == frame)
+    	return 1;
+    return (modification->function != CF_JUMP);
 	}
-	if (!first)
+
+float change_value(change_t* modification, U16 frame)
+{
+    change_t* previous = modification;
+    while (modification && modification->frame < frame)
+    {
+	previous = modification;
+	modification = modification->next;
+    }
+    if (!modification)
 		return previous->value;
-	if (first->frame == frame)
+    if (modification->frame == frame)
 	{
-		float result;
 		do 
 		{
-			result = first->value;
-			first = first->next;
+	    previous = modification;
+	    modification = modification->next;
 		}
-		while (first && first->frame == frame);
-		return result;
+	while (modification && modification->frame == frame);
+	return previous->value;
 	}
-	switch (first->function)
+    switch (modification->function)
 	{
 		case CF_PUT:
-			return first->value;
+	    return modification->value;
 		case CF_CHANGE:
 		{
-			float fraction = (frame - previous->frame) / (float)(first->frame - previous->frame);
-			return interpolateParameter(previous->value, first->value, fraction, first->interpolation);
+	    float fraction = (frame - previous->frame) / (float)(modification->frame - previous->frame);
+	    return interpolateScalar(previous->value, modification->value, fraction, modification->interpolation);
+	}
+	case CF_QCHANGE:
+	{
+	    float fraction = (frame - previous->frame) / (float)(modification->frame - previous->frame);
+	    return calculateSpline(modification, fraction);
 		}
 		case CF_JUMP:
 			return previous->value;
@@ -134,7 +206,7 @@ float change_value(change_t* first, U16 frame)
 	}
 }
 
-changeFilter_t* changeFilter_new(U16 frame, int function, FILTER* value, interpolation_t* inter)
+changeFilter_t* changeFilter_new(U16 frame, int function, FILTERLIST* value, interpolation_t* inter)
 {
 	changeFilter_t* newChange = (changeFilter_t*)malloc(sizeof(changeFilter_t));
 	changeFilter_init(newChange);
@@ -149,6 +221,7 @@ void changeFilter_free(changeFilter_t *change)
 {
 	if (change->next)
 		changeFilter_free(change->next);
+    free(change->value);
 	free(change);
 }
 
@@ -161,147 +234,511 @@ void changeFilter_append(changeFilter_t* first, changeFilter_t* newChange)
 {
 	while (first->next)
 		first = first->next;
+    if (!first->value || !newChange->value)
 	first->next = newChange;
+    else
+    {
+    	int i, mergedCount = 0;
+    	int common = first->value->num < newChange->value->num ? first->value->num : newChange->value->num;
+    	for (i = 0; i < common; i++)
+    	{
+    	    mergedCount++;
+    	    if (newChange->value->filter[i]->type != first->value->filter[i]->type)
+    	    	mergedCount++;
+    	}
+    	mergedCount = mergedCount + first->value->num - common + newChange->value->num - common;
+    	if (mergedCount > 8)
+    	{
+    	    char* list1;
+    	    char* list2;
+    	    char* newList;
+    	    list1 = (char*)malloc(1);
+    	    *list1 = '\0';
+    	    for (i = 0; i < first->value->num; i++)
+    	    {
+    	    	newList = (char*)malloc(strlen(list1) + strlen(filtername[first->value->filter[i]->type]) + 2);
+    	    	newList = strcat(strcat(list1, "+"), filtername[first->value->filter[i]->type]);
+    	    	free(list1);
+    	    	list1 = newList;
+    	    }
+    	    list2 = (char*)malloc(1);
+    	    *list2 = '\0';
+    	    for (i = 0; i < newChange->value->num; i++)
+    	    {
+    	    	newList = (char*)malloc(strlen(list1) + strlen(filtername[newChange->value->filter[i]->type]) + 2);
+    	    	newList = strcat(strcat(list2, "+"), filtername[newChange->value->filter[i]->type]);
+    	    	free(list2);
+    	    	list2 = newList;
+    	    }
+    	    syntaxerror("filterlists %s and %s cannot be interpolated.", list1, list2);
+    	}
+    	first->next = newChange;
+    }
 }
 
 RGBA interpolateColor(RGBA c1, RGBA c2, float ratio, interpolation_t* inter)
 {
     RGBA c;
-    c.r = c1.r * (1-ratio) + c2.r * ratio;
-    c.g = c1.g * (1-ratio) + c2.g * ratio;
-    c.b = c1.b * (1-ratio) + c2.b * ratio;
-    c.a = c1.a * (1-ratio) + c2.a * ratio;
+    c.r = interpolateScalar(c1.r, c2.r, ratio, inter);
+    c.g = interpolateScalar(c1.g, c2.g, ratio, inter);
+    c.b = interpolateScalar(c1.b, c2.b, ratio, inter);
+    c.a = interpolateScalar(c1.a, c2.a, ratio, inter);
     return c;
 }
 
-FILTER* interpolateFilter(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
+GRADIENT* interpolateNodes(GRADIENT* g1, GRADIENT* g2, float fraction, interpolation_t* inter)
 {
-	if(!filter1 && !filter2)
-		return 0;
-	if(!filter1)
-		return interpolateFilter(filter2,filter1,1-ratio, inter);
+    if (g1->num != g2->num)
+    	syntaxerror("Internal error: gradients are not equal in size");
 
-	if(filter2 && filter2->type != filter1->type)
-		syntaxerror("can't interpolate between %s and %s filters yet", filtername[filter1->type], filtername[filter2->type]);
+    int i;
+    GRADIENT* g = (GRADIENT*) malloc(sizeof(GRADIENT));
+    g->ratios = rfx_calloc(16*sizeof(U8));
+    g->rgba = rfx_calloc(16*sizeof(RGBA));
+    g->num = g1->num;
+    for (i = 0; i < g->num; i++)
+    {
+    	g->ratios[i] = interpolateScalar(g1->ratios[i], g2->ratios[i], fraction, inter);
+    	g->rgba[i] = interpolateColor(g1->rgba[i], g2->rgba[i], fraction, inter);
+    }
+    return g;
+}
+
+void copyGradient(GRADIENT* dest, GRADIENT* source)
+{
+    dest->num = source->num;
+    memcpy(dest->ratios, source->ratios, source->num * sizeof(U8));
+    memcpy(dest->rgba, source->rgba, source->num * sizeof(RGBA));
+}
+
+void insertNode(GRADIENT* g, int pos)
+{
+    memmove(&g->ratios[pos + 1], &g->ratios[pos], (g->num - pos) * sizeof(U8));
+    memmove(&g->rgba[pos + 1], &g->rgba[pos], (g->num - pos) * sizeof(RGBA));
+    if (pos == 0)
+    {
+    	g->ratios[0] = g->ratios[1] / 2;
+    	g->rgba[0] = g->rgba[1];
+    }
+    else
+    	if (pos == g->num)
+    	{
+    	    g->ratios[pos] = (255 + g->ratios[g->num - 1]) / 2;
+    	    g->rgba[pos] = g->rgba[pos - 1];
+    	}
+    	else
+    	{
+	    g->ratios[pos] = (g->ratios[pos - 1] + g->ratios[pos + 1]) / 2;
+	    g->rgba[pos] = interpolateColor(g->rgba[pos - 1], g->rgba[pos + 1], 0.5, 0);
+    	}
+    g->num++;
+}
+
+void insertOptimalNode(GRADIENT* g)
+{
+    int i, next_gap;
+    int pos = 0;
+    int gap = g->ratios[0];
+    for (i = 0; i < g->num - 1; i++)
+    {
+    	next_gap = g->ratios[i + 1] - g->ratios[i];
+    	if (next_gap > gap)
+    	{
+    	    gap = next_gap;
+    	    pos = i + 1;
+    	}
+    }
+    next_gap = 255 - g->ratios[g->num -1];
+    if (next_gap > gap)
+    	pos = g->num;
+    insertNode(g, pos);
+}
    
-	if(filter1->type == FILTERTYPE_BLUR)
+void growGradient(GRADIENT* start, int size)
+{
+    while (start->num < size)
+    	insertOptimalNode(start);
+}
+
+GRADIENT* interpolateGradient(GRADIENT* g1, GRADIENT* g2, float fraction, interpolation_t* inter)
+{
+    int i;
+    GRADIENT g;
+    g.ratios = rfx_calloc(16*sizeof(U8));
+    g.rgba = rfx_calloc(16*sizeof(RGBA));
+
+    if (g1->num > g2->num)
+    {
+    	copyGradient(&g, g2);
+    	growGradient(&g, g1->num);
+    	GRADIENT* result = interpolateNodes(g1, &g, fraction, inter);
+    	rfx_free(g.rgba);
+    	rfx_free(g.ratios);
+    	return result;
+    }
+    else
+    	if (g1->num < g2->num)
+    	{
+    	    copyGradient(&g, g1);
+    	    growGradient(&g, g2->num);
+    	    GRADIENT* result = interpolateNodes(&g, g2, fraction, inter);
+    	    rfx_free(g.rgba);
+    	    rfx_free(g.ratios);
+    	    return result;
+    	}
+    	else
+    	    return interpolateNodes(g1, g2, fraction, inter);
+}
+
+FILTER* copyFilter(FILTER* original)
+{
+    if (!original)
+	return original;
+    FILTER* copy = swf_NewFilter(original->type);
+    switch (original->type)
+    {
+	case FILTERTYPE_BLUR:
+	    memcpy(copy, original, sizeof(FILTER_BLUR));
+	    break;
+	case FILTERTYPE_GRADIENTGLOW:
+	{
+	    memcpy(copy, original, sizeof(FILTER_GRADIENTGLOW));
+	    FILTER_GRADIENTGLOW* ggcopy = (FILTER_GRADIENTGLOW*)copy;
+	    ggcopy->gradient = (GRADIENT*)malloc(sizeof(GRADIENT));
+	    ggcopy->gradient->ratios = (U8*)malloc(16 * sizeof(U8));
+	    ggcopy->gradient->rgba = (RGBA*)malloc(16 * sizeof(RGBA));
+	    copyGradient(ggcopy->gradient, ((FILTER_GRADIENTGLOW*)original)->gradient);
+	}
+	    break;
+	case FILTERTYPE_DROPSHADOW:
+	    memcpy(copy, original, sizeof(FILTER_DROPSHADOW));
+	    break;
+	case FILTERTYPE_BEVEL:
+	    memcpy(copy, original, sizeof(FILTER_BEVEL));
+	    break;
+	default: syntaxerror("Internal error: unsupported filterype, cannot copy");
+    }
+    return copy;
+}
+
+FILTER* interpolateBlur(FILTER* filter1, FILTER* filter2, float ratio, interpolation_t* inter)
 	{
 		FILTER_BLUR*f1 = (FILTER_BLUR*)filter1;
 		FILTER_BLUR*f2 = (FILTER_BLUR*)filter2;
-		if(f2 && f1->blurx == f2->blurx && f1->blury == f2->blury)
-			return 0;
+    if (!f1)
+    	f1 = noBlur;
+    if (!f2)
+    	f2 = noBlur;
+    if(f1->blurx == f2->blurx && f1->blury == f2->blury)
+	return copyFilter(filter1);
 		FILTER_BLUR*f = (FILTER_BLUR*)swf_NewFilter(FILTERTYPE_BLUR);
-		f->blurx= (f1->blurx)*(1-ratio) + (f2?f2->blurx:0)*ratio;
-		f->blury= (f1->blury)*(1-ratio) + (f2?f2->blury:0)*ratio;
-		f->passes= (f1->passes)*(1-ratio) + (f2?f2->passes:0)*ratio;
+    f->blurx= interpolateScalar(f1->blurx, (f2->blurx), ratio, inter);
+    f->blury= interpolateScalar(f1->blury, (f2->blury), ratio, inter);
+    f->passes= interpolateScalar(f1->passes, (f2->passes), ratio, inter);
 		return (FILTER*)f;
 		}
-	else
-		if (filter1->type == FILTERTYPE_DROPSHADOW)
+
+void matchDropshadowFlags(FILTER_DROPSHADOW* unset, FILTER_DROPSHADOW* target)
+{
+    unset->innershadow = target->innershadow;
+    unset->knockout = target->knockout;
+    unset->composite = target->composite;
+}
+
+FILTER* interpolateDropshadow(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
 		{
 			FILTER_DROPSHADOW*f1 = (FILTER_DROPSHADOW*)filter1;
 			FILTER_DROPSHADOW*f2 = (FILTER_DROPSHADOW*)filter2;
-			if(f2 && !memcmp(&f1->color,&f2->color,sizeof(RGBA)) && f1->strength == f2->strength && 
+    if (!f1)
+    	f1 = noDropshadow;
+    if (!f2)
+    	f2 = noDropshadow;
+    if(!memcmp(&f1->color,&f2->color,sizeof(RGBA)) && f1->strength == f2->strength &&
 				f1->blurx == f2->blurx && f1->blury == f2->blury && 
 				f1->angle == f2->angle && f1->distance == f2->distance)
-				return 0;
+		return copyFilter(filter1);
 			FILTER_DROPSHADOW*f = (FILTER_DROPSHADOW*)swf_NewFilter(FILTERTYPE_DROPSHADOW);
 			memcpy(f, f1, sizeof(FILTER_DROPSHADOW));
 			f->color = interpolateColor(f1->color, f2->color, ratio, inter);
-			f->blurx= (f1->blurx)*(1-ratio) + (f2?f2->blurx:0)*ratio;
-			f->blury= (f1->blury)*(1-ratio) + (f2?f2->blury:0)*ratio;
-			f->passes= (f1->passes)*(1-ratio) + (f2?f2->passes:0)*ratio;
-			f->angle= (f1->angle)*(1-ratio) + (f2?f2->angle:0)*ratio;
-			f->distance= (f1->distance)*(1-ratio) + (f2?f2->distance:0)*ratio;
-			f->strength= (f1->strength)*(1-ratio) + (f2?f2->strength:0)*ratio;
-			return (FILTER*)f;
+    f->blurx= interpolateScalar(f1->blurx, (f2->blurx), ratio, inter);
+    f->blury= interpolateScalar(f1->blury, (f2->blury), ratio, inter);
+    f->passes= interpolateScalar(f1->passes, (f2->passes), ratio, inter);
+    f->angle= interpolateScalar(f1->angle, (f2->angle), ratio, inter);
+    f->distance= interpolateScalar(f1->distance, (f2->distance), ratio, inter);
+    f->strength= interpolateScalar(f1->strength, (f2->strength), ratio, inter);
+    if (f1 == noDropshadow)
+    {
+    	if (f2 != noDropshadow)
+    	    matchDropshadowFlags(f, f2);
 		}
 		else
-			if (filter1->type == FILTERTYPE_BEVEL)
+    	if (f2 == noDropshadow)
+	    matchDropshadowFlags(f, f1);
+	else
+	    if (ratio > 0.5)
+    		matchDropshadowFlags(f, f2);
+	    else
+    		matchDropshadowFlags(f, f1);
+    return (FILTER*)f;
+}
+
+void matchBevelFlags(FILTER_BEVEL* unset, FILTER_BEVEL* target)
+{
+    unset->innershadow = target->innershadow;
+    unset->knockout = target->knockout;
+    unset->composite = target->composite;
+    unset->ontop = target->ontop;
+}
+
+FILTER* interpolateBevel(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
 			{
 				FILTER_BEVEL*f1 = (FILTER_BEVEL*)filter1;
 				FILTER_BEVEL*f2 = (FILTER_BEVEL*)filter2;
-				if(f2 && !memcmp(&f1->shadow,&f2->shadow,sizeof(RGBA)) && 
+    if (!f1)
+    	f1 = noBevel;
+    if (!f2)
+    	f2 = noBevel;
+    if(!memcmp(&f1->shadow,&f2->shadow,sizeof(RGBA)) &&
 					!memcmp(&f1->highlight,&f2->highlight,sizeof(RGBA)) && 
 					f1->blurx == f2->blurx && f1->blury == f2->blury && f1->angle == f2->angle && f1->strength == f2->strength && f1->distance == f2->distance)
-					return 0;
+		return copyFilter(filter1);
 				FILTER_BEVEL*f = (FILTER_BEVEL*)swf_NewFilter(FILTERTYPE_BEVEL);
 				memcpy(f, f1, sizeof(FILTER_BEVEL));
 				f->shadow = interpolateColor(f1->shadow, f2->shadow, ratio, inter);
 				f->highlight = interpolateColor(f1->highlight, f2->highlight, ratio, inter);
-				f->blurx= (f1->blurx)*(1-ratio) + (f2?f2->blurx:0)*ratio;
-				f->blury= (f1->blury)*(1-ratio) + (f2?f2->blury:0)*ratio;
-				f->passes= (f1->passes)*(1-ratio) + (f2?f2->passes:0)*ratio;
-				f->angle= (f1->angle)*(1-ratio) + (f2?f2->angle:0)*ratio;
-				f->distance= (f1->distance)*(1-ratio) + (f2?f2->distance:0)*ratio;
-				f->strength= (f1->strength)*(1-ratio) + (f2?f2->strength:0)*ratio;
+    f->blurx= interpolateScalar(f1->blurx, (f2->blurx), ratio, inter);
+    f->blury= interpolateScalar(f1->blury, (f2->blury), ratio, inter);
+    f->passes= interpolateScalar(f1->passes, (f2->passes), ratio, inter);
+    f->angle= interpolateScalar(f1->angle, (f2->angle), ratio, inter);
+    f->distance= interpolateScalar(f1->distance, (f2->distance), ratio, inter);
+    f->strength= interpolateScalar(f1->strength, (f2->strength), ratio, inter);
+    if (f1 == noBevel)
+    {
+    	if (f2 != noBevel)
+    	    matchBevelFlags(f, f2);
+    }
+    else
+    	if (f2 == noBevel)
+	    matchBevelFlags(f, f1);
+	else
+	    if (ratio > 0.5)
+    		matchBevelFlags(f, f2);
+	    else
+    		matchBevelFlags(f, f1);
 				return (FILTER*)f;
-			} /*else if (filter1->type == FILTERTYPE_GRADIENTGLOW) {
+}
+
+void matchGradientGlowFlags(FILTER_GRADIENTGLOW* unset, FILTER_GRADIENTGLOW* target)
+{
+    unset->innershadow = target->innershadow;
+    unset->knockout = target->knockout;
+    unset->composite = target->composite;
+    unset->ontop = target->ontop;
+}
+
+FILTER* interpolateGradientGlow(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
+{
+    FILTER_GRADIENTGLOW*f1 = (FILTER_GRADIENTGLOW*)filter1;
+    FILTER_GRADIENTGLOW*f2 = (FILTER_GRADIENTGLOW*)filter2;
+    if (!f1)
+    	f1 = noGradientGlow;
+    if (!f2)
+    	f2 = noGradientGlow;
+    if(f1->gradient->num == f2->gradient->num &&
+    		!memcmp(&f1->gradient->ratios,&f2->gradient->ratios,f1->gradient->num * sizeof(U8)) &&
+    		!memcmp(&f1->gradient->rgba,&f2->gradient->rgba,f1->gradient->num * sizeof(RGBA)) &&
+		f1->blurx == f2->blurx && f1->blury == f2->blury && f1->angle == f2->angle && f1->strength == f2->strength && f1->distance == f2->distance)
+		return copyFilter(filter1);
 	FILTER_GRADIENTGLOW*f = (FILTER_GRADIENTGLOW*)swf_NewFilter(FILTERTYPE_GRADIENTGLOW);
-	// can't interpolate gradients
-	memcpy(f, filter1, sizeof(FILTER_GRADIENTGLOW));
+    memcpy(f, f1, sizeof(FILTER_GRADIENTGLOW));
+    f->blurx= interpolateScalar(f1->blurx, (f2->blurx), ratio, inter);
+    f->blury= interpolateScalar(f1->blury, (f2->blury), ratio, inter);
+    f->passes= interpolateScalar(f1->passes, (f2->passes), ratio, inter);
+    f->angle= interpolateScalar(f1->angle, (f2->angle), ratio, inter);
+    f->distance= interpolateScalar(f1->distance, (f2->distance), ratio, inter);
+    f->strength= interpolateScalar(f1->strength, (f2->strength), ratio, inter);
+    f->gradient= interpolateGradient(f1->gradient, f2->gradient, ratio, inter);
+    if (f1 == noGradientGlow)
+    {
+    	if (f2 != noGradientGlow)
+    	    matchGradientGlowFlags(f, f2);
+    }
+    else
+    	if (f2 == noGradientGlow)
+	    matchGradientGlowFlags(f, f1);
+	else
+	    if (ratio > 0.5)
+    		matchGradientGlowFlags(f, f2);
+	    else
+    		matchGradientGlowFlags(f, f1);
 	return (FILTER*)f;
-    }*/ else
-				syntaxerror("can't interpolate %s filters yet", filtername[filter1->type]);
+}
+
+FILTER* interpolateFilter(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter)
+{
+    if(!filter1 && !filter2)
+	return 0;
+
+    int filter_type;
+    if (!filter1)
+    	filter_type = filter2->type;
+    else
+    	if (!filter2)
+    	    filter_type = filter1->type;
+    	else
+	    if(filter2->type != filter1->type)
+		syntaxerror("can't interpolate between %s and %s filters yet", filtername[filter1->type], filtername[filter2->type]);
+	    else
+	    	filter_type = filter1->type;
+
+    switch (filter_type)
+    {
+        case FILTERTYPE_BLUR:
+            return interpolateBlur(filter1, filter2, ratio, inter);
+        case FILTERTYPE_BEVEL:
+            return interpolateBevel(filter1, filter2, ratio, inter);
+        case FILTERTYPE_DROPSHADOW:
+            return interpolateDropshadow(filter1, filter2, ratio, inter);
+        case FILTERTYPE_GRADIENTGLOW:
+            return interpolateGradientGlow(filter1, filter2, ratio, inter);
+        default:
+            syntaxerror("Filtertype %s not supported yet.\n", filtername[filter1->type]);
+    }
 	return 0;
 }
 
-FILTER* copyFilter(FILTER* original)
+FILTERLIST* copyFilterList(FILTERLIST* original)
 {
 	if (!original)
 		return original;
-	FILTER* copy = swf_NewFilter(original->type);
-	switch (original->type)
+    int i;
+    FILTERLIST* copy = (FILTERLIST*)malloc(sizeof(FILTERLIST));
+    copy->num = original->num;
+    for (i = 0; i < copy->num; i++)
+    	copy->filter[i] = copyFilter(original->filter[i]);
+    return copy;
+}
+
+FILTER* noFilter(int type)
+{
+    switch (type)
 	{
 		case FILTERTYPE_BLUR:
-			memcpy(copy, original, sizeof(FILTER_BLUR));
+    	    return (FILTER*)noBlur;
 			break;
-		case FILTERTYPE_GRADIENTGLOW:
-			memcpy(copy, original, sizeof(FILTER_GRADIENTGLOW));
+    	case FILTERTYPE_BEVEL:
+    	    return (FILTER*)noBevel;
 			break;
 		case FILTERTYPE_DROPSHADOW:
-			memcpy(copy, original, sizeof(FILTER_DROPSHADOW)); 
+    	    return (FILTER*)noDropshadow;
 			break;
-		case FILTERTYPE_BEVEL:
-			memcpy(copy, original, sizeof(FILTER_BEVEL)); 
+    	case FILTERTYPE_GRADIENTGLOW:
+    	    return (FILTER*)noGradientGlow;
 			break;
-		default: printf("unsupported filterype");
+    	default:
+    	    syntaxerror("Internal error: unsupported filtertype, cannot match filterlists");
 	}
-	return copy;
+    return 0;
 }
 
-FILTER* changeFilter_value(changeFilter_t* first, U16 frame)
+FILTERLIST* interpolateFilterList(FILTERLIST* list1, FILTERLIST* list2, float ratio, interpolation_t* inter)
 {
-	changeFilter_t* previous = first;
-	while (first && first->frame < frame)
+    if (!list1 && !list2)
+	return list1;
+    FILTERLIST start, target, dummy;
+    dummy.num = 0;
+    if (!list1)
+    	list1 = &dummy;
+    if (!list2)
+    	list2 = &dummy;
+    int i, j = 0;
+    int common = list1->num < list2->num ? list1->num : list2->num;
+        for (i = 0; i < common; i++)
+    {
+    	start.filter[j] = list1->filter[i];
+    	if (list2->filter[i]->type == list1->filter[i]->type)
+    	{
+    	    target.filter[j] = list2->filter[i];
+    	    j++;
+    	}
+    	else
+    	{
+    	    target.filter[j] = noFilter(list1->filter[i]->type);
+    	    j++;
+    	    start.filter[j] = noFilter(list2->filter[i]->type);
+    	    target.filter[j] = list2->filter[i];
+    	    j++;
+    	}
+    }
+    if (list1->num > common)
+    	for (i = common; i < list1->num; i++)
+    	{
+    	    start.filter[j] = list1->filter[i];
+    	    target.filter[j] = noFilter(list1->filter[i]->type);
+    	    j++;
+    	}
+    if (list2->num > common)
+    	for (i = common; i < list2->num; i++)
+    	{
+    	    start.filter[j] = noFilter(list2->filter[i]->type);
+    	    target.filter[j] = list2->filter[i];
+    	    j++;
+    	}
+    start.num = j;
+    target.num = j;
+    FILTERLIST* mixedList = (FILTERLIST*)malloc(sizeof(FILTERLIST));
+    mixedList->num = j;
+    for (i = 0; i < j; i++)
+    	mixedList->filter[i] = interpolateFilter(start.filter[i], target.filter[i], ratio, inter);
+    return mixedList;
+}
+
+int changeFilter_differs(changeFilter_t* modification, U16 frame)
+{
+    changeFilter_t* previous = modification;
+    while (modification && modification->frame < frame)
 	{
-		previous = first;
-		first = first->next;
+	previous = modification;
+	modification = modification->next;
 	}
-	if (!first)
-		return copyFilter(previous->value);
-	if (first->frame == frame)
+    if (!modification)
+	return 0;
+    if (modification->frame == frame)
+    	return 1;
+    return (modification->function != CF_JUMP);
+}
+
+FILTERLIST* changeFilter_value(changeFilter_t* modification, U16 frame)
+{
+    changeFilter_t* previous = modification;
+    while (modification && modification->frame < frame)
+    {
+	previous = modification;
+	modification = modification->next;
+    }
+    if (!modification)
+	return copyFilterList(previous->value);
+    if (modification->frame == frame)
 	{
-		FILTER* result;
 		do 
 		{
-			result = first->value;
-			first = first->next;
+	    previous = modification;
+	    modification = modification->next;
 		}
-		while (first && first->frame == frame);
-		return copyFilter(result);
+	while (modification && modification->frame == frame);
+	return copyFilterList(previous->value);
 	}
-	switch (first->function)
+    switch (modification->function)
 	{
 		case CF_PUT:
-			return copyFilter(first->value);
+	    return copyFilterList(modification->value);
 		case CF_CHANGE:
 		{
-			float fraction = (frame - previous->frame) / (float)(first->frame - previous->frame);
-			return interpolateFilter(previous->value, first->value, fraction, first->interpolation);
+	    float fraction = (frame - previous->frame) / (float)(modification->frame - previous->frame);
+	    return interpolateFilterList(previous->value, modification->value, fraction, modification->interpolation);
 		}
 		case CF_JUMP:
-			return copyFilter(previous->value);
+	    return copyFilterList(previous->value);
 		default:
 			return 0;
 	}
@@ -354,7 +791,7 @@ void history_begin(history_t* past, char* parameter, U16 frame, TAG* tag, float
 	dictionary_put2(past->changes, parameter, first);
 }
 
-void history_beginFilter(history_t* past, U16 frame, TAG* tag, FILTER* value)
+void history_beginFilter(history_t* past, U16 frame, TAG* tag, FILTERLIST* value)
 {
 	changeFilter_t* first = changeFilter_new(frame, CF_PUT, value, 0);
 	past->firstTag = tag;
@@ -372,7 +809,7 @@ void history_remember(history_t* past, char* parameter, U16 frame, int function,
 	}
 }
 
-void history_rememberFilter(history_t* past, U16 frame, int function, FILTER* value, interpolation_t* inter)
+void history_rememberFilter(history_t* past, U16 frame, int function, FILTERLIST* value, interpolation_t* inter)
 {
 	changeFilter_t* first = dictionary_lookup(past->changes, "filter");
 	if (first) //should always be true
@@ -382,6 +819,15 @@ void history_rememberFilter(history_t* past, U16 frame, int function, FILTER* va
 	}
 }
 
+int history_change(history_t* past, U16 frame, char* parameter)
+{
+    change_t* first = dictionary_lookup(past->changes, parameter);
+    if (first)	//should always be true.
+	return change_differs(first, frame);
+    printf("no history found for parameter %s\n", parameter);
+    return 0;
+}
+
 float history_value(history_t* past, U16 frame, char* parameter)
 {
 	change_t* first = dictionary_lookup(past->changes, parameter);
@@ -391,7 +837,16 @@ float history_value(history_t* past, U16 frame, char* parameter)
 	return 0;
 }
 
-FILTER* history_valueFilter(history_t* past, U16 frame)
+int history_changeFilter(history_t* past, U16 frame)
+{
+    changeFilter_t* first = dictionary_lookup(past->changes, "filter");
+    if (first)	//should always be true.
+	return changeFilter_differs(first, frame);
+    printf("no history found for parameter filter\n");
+    return 0;
+}
+
+FILTERLIST* history_valueFilter(history_t* past, U16 frame)
 {
 	changeFilter_t* first = dictionary_lookup(past->changes, "filter");
 	if (first)	//should always be true.