1 #include <stdlib.h>
2 #include <stdio.h>
3 #include "../rfxswf.h"
4 
5 char* filtername[] = {"dropshadow","blur","glow","bevel","gradientglow","convolution","colormatrix","gradientbevel", 0};
6 
swf_SetFilter(TAG * tag,FILTER * filter)7 void swf_SetFilter(TAG*tag, FILTER*filter)
8 {
9     swf_SetU8(tag, filter->type);
10     if(filter->type == FILTERTYPE_BLUR) {
11 	FILTER_BLUR*f = (FILTER_BLUR*)filter;
12 	swf_SetFixed(tag, f->blurx);
13 	swf_SetFixed(tag, f->blury);
14 	U8 flags = f->passes << 3;
15 	swf_SetU8(tag, flags);
16     } else if(filter->type == FILTERTYPE_GLOW) {
17 	FILTER_GLOW*f = (FILTER_GLOW*)filter;
18     } else if(filter->type == FILTERTYPE_DROPSHADOW) {
19 	FILTER_DROPSHADOW*f = (FILTER_DROPSHADOW*)filter;
20 	swf_SetRGBA(tag, &f->color);
21 	swf_SetFixed(tag, f->blurx);
22 	swf_SetFixed(tag, f->blury);
23 	swf_SetFixed(tag, f->angle);
24 	swf_SetFixed(tag, f->distance);
25 	swf_SetFixed8(tag, f->strength);
26 	U8 flags = f->innershadow<<7|f->knockout<<6|f->composite<<5|f->passes;
27 	swf_SetU8(tag, flags);
28     } else if(filter->type == FILTERTYPE_GRADIENTGLOW) {
29 	FILTER_GRADIENTGLOW*f = (FILTER_GRADIENTGLOW*)filter;
30 	swf_SetU8(tag, f->gradient->num);
31 	int s;
32 	for(s=0;s<f->gradient->num;s++)
33 	    swf_SetRGBA(tag, &f->gradient->rgba[s]);
34 	for(s=0;s<f->gradient->num;s++)
35 	    swf_SetU8(tag, f->gradient->ratios[s]);
36 
37 	swf_SetFixed(tag, f->blurx);
38 	swf_SetFixed(tag, f->blury);
39 	swf_SetFixed(tag, f->angle);
40 	swf_SetFixed(tag, f->distance);
41 	swf_SetFixed8(tag, f->strength);
42 	U8 flags = f->passes|f->innershadow<<7|f->knockout<<6|f->composite<<5|f->ontop<<4;
43 	swf_SetU8(tag, flags);
44     } else if(filter->type == FILTERTYPE_BEVEL) {
45 	FILTER_BEVEL*f = (FILTER_BEVEL*)filter;
46 	swf_SetRGBA(tag, &f->shadow);
47 	swf_SetRGBA(tag, &f->highlight);
48 	swf_SetFixed(tag, f->blurx);
49 	swf_SetFixed(tag, f->blury);
50 	swf_SetFixed(tag, f->angle);
51 	swf_SetFixed(tag, f->distance);
52 	swf_SetFixed8(tag, f->strength);
53 	U8 flags = f->passes|f->innershadow<<7|f->knockout<<6|f->composite<<5|f->ontop<<4;
54 	swf_SetU8(tag, flags);
55     } else {
56 	fprintf(stderr, "Writing of filter type %02x not supported yet\n", filter->type);
57     }
58 }
59 
swf_GetFilter(TAG * tag)60 FILTER*swf_GetFilter(TAG*tag)
61 {
62     U8 type = swf_GetU8(tag);
63     FILTER*filter;
64     if(type == FILTERTYPE_BLUR) {
65 	FILTER_BLUR* f = (FILTER_BLUR*)rfx_calloc(sizeof(FILTER_BLUR));
66 	f->type = type;
67 	f->blurx = swf_GetFixed(tag);
68 	f->blury = swf_GetFixed(tag);
69 	U8 flags = swf_GetU8(tag);
70 	f->passes = (flags&15)<<3;
71 	return (FILTER*)f;
72     } else if(type == FILTERTYPE_GLOW) {
73 	FILTER_GLOW* f = (FILTER_GLOW*)rfx_calloc(sizeof(FILTER_GLOW));
74 	f->type = type;
75 	swf_GetRGBA(tag, &f->rgba);
76 	f->blurx = swf_GetFixed(tag);
77 	f->blury = swf_GetFixed(tag);
78 	f->strength = swf_GetFixed8(tag);
79 	U8 flags = swf_GetU8(tag);
80 	f->passes = flags&31;
81 	f->innerglow = (flags>>7)&1;
82 	f->knockout = (flags>>6)&1;
83 	f->composite = (flags>>5)&1;
84 	return (FILTER*)f;
85     } else if(type == FILTERTYPE_GRADIENTGLOW) {
86 	FILTER_GRADIENTGLOW* f = (FILTER_GRADIENTGLOW*)rfx_calloc(sizeof(FILTER_GRADIENTGLOW));
87 	f->type = type;
88 	f->gradient = (GRADIENT*)rfx_calloc(sizeof(GRADIENT));
89 	f->gradient->num = swf_GetU8(tag);
90 	f->gradient->rgba = (RGBA*)rfx_calloc(sizeof(RGBA)*f->gradient->num);
91 	f->gradient->ratios = (U8*)rfx_calloc(sizeof(U8)*f->gradient->num);
92 	int s;
93 	for(s=0;s<f->gradient->num;s++)
94 	    swf_GetRGBA(tag, &f->gradient->rgba[s]);
95 	for(s=0;s<f->gradient->num;s++)
96 	    f->gradient->ratios[s] = swf_GetU8(tag);
97 
98 	f->blurx = swf_GetFixed(tag);
99 	f->blury = swf_GetFixed(tag);
100 	f->angle = swf_GetFixed(tag);
101 	f->distance = swf_GetFixed(tag);
102 	f->strength = swf_GetFixed8(tag);
103 	U8 flags = swf_GetU8(tag);
104 	f->passes = flags&15;
105 	f->innershadow = (flags>>7)&1;
106 	f->knockout = (flags>>6)&1;
107 	f->composite = (flags>>5)&1;
108 	f->ontop = (flags>>4)&1;
109 	return (FILTER*)f;
110     } else if(type == FILTERTYPE_DROPSHADOW) {
111 	FILTER_DROPSHADOW* f = (FILTER_DROPSHADOW*)rfx_calloc(sizeof(FILTER_DROPSHADOW));
112 	f->type = type;
113 	swf_GetRGBA(tag, &f->color);
114 	f->blurx = swf_GetFixed(tag);
115 	f->blury = swf_GetFixed(tag);
116 	f->angle = swf_GetFixed(tag);
117 	f->distance = swf_GetFixed(tag);
118 	f->strength = swf_GetFixed8(tag);
119 	U8 flags = swf_GetU8(tag);
120 	f->passes = flags&31;
121 	f->innershadow = (flags>>7)&1;
122 	f->knockout = (flags>>6)&1;
123 	f->composite = (flags>>5)&1;
124 	return (FILTER*)f;
125     } else if(type == FILTERTYPE_BEVEL) {
126 	FILTER_BEVEL* f = (FILTER_BEVEL*)rfx_calloc(sizeof(FILTER_BEVEL));
127 	f->type = type;
128 	swf_GetRGBA(tag, &f->shadow);
129 	swf_GetRGBA(tag, &f->highlight);
130 	f->blurx = swf_GetFixed(tag);
131 	f->blury = swf_GetFixed(tag);
132 	f->angle = swf_GetFixed(tag);
133 	f->distance = swf_GetFixed(tag);
134 	f->strength = swf_GetFixed8(tag);
135 	U8 flags = swf_GetU8(tag);
136 	f->passes = flags&15;
137 	f->innershadow = (flags>>7)&1;
138 	f->knockout = (flags>>6)&1;
139 	f->composite = (flags>>5)&1;
140 	f->ontop = (flags>>4)&1;
141 	return (FILTER*)f;
142     } else {
143 	fprintf(stderr, "Reading of filter type %02x not supported yet\n", type);
144     }
145     return 0;
146 }
147 
swf_NewFilter(U8 type)148 FILTER*swf_NewFilter(U8 type)
149 {
150     FILTER*f = 0;
151     if(type == FILTERTYPE_BLUR)
152 	f = (FILTER*)rfx_calloc(sizeof(FILTER_BLUR));
153     else if(type == FILTERTYPE_GRADIENTGLOW)
154 	f = (FILTER*)rfx_calloc(sizeof(FILTER_GRADIENTGLOW));
155     else if(type == FILTERTYPE_DROPSHADOW)
156 	f = (FILTER*)rfx_calloc(sizeof(FILTER_DROPSHADOW));
157     else if(type == FILTERTYPE_BEVEL)
158 	f = (FILTER*)rfx_calloc(sizeof(FILTER_BEVEL));
159     else
160 	fprintf(stderr, "Creation of filter type %02x not supported yet\n", type);
161     if(f)
162 	f->type = type;
163     return f;
164 }
165 
swf_DeleteFilter(FILTER * f)166 void swf_DeleteFilter(FILTER*f)
167 {
168     //FIXME
169     free(f);
170 }
171