2 // from ffmpeg vf_boxblur
4 template<class dst_t, class src_t> static inline
5 void blurt(dst_t *dst, int dst_step, src_t *src, int src_step,
6 int len, int radius, float s)
8 if( radius > len ) radius = len;
9 const int length = radius*2 + 1;
10 const int inv = s * ((1<<16) + length/2)/length;
11 int x, n, sum = src[radius*src_step];
13 for( x=0; x<radius; ++x )
14 sum += src[x*src_step]<<1;
15 sum = sum*inv + (1<<15);
16 for( x=0; x<=radius; ++x ) {
17 sum += (src[(radius+x)*src_step] - src[(radius-x)*src_step])*inv;
18 dst[x*dst_step] = sum>>16;
22 sum += (src[(radius+x)*src_step] - src[(x-radius-1)*src_step])*inv;
23 dst[x*dst_step] = sum >>16;
25 for ( ; x<len; ++x ) {
26 sum += (src[(2*len-radius-x-1)*src_step] - src[(x-radius-1)*src_step])*inv;
27 dst[x*dst_step] = sum>>16;
30 // specialize const float *src
31 template<class dst_t> static inline
32 void blurt(dst_t *dst, int dst_step, const float *src, int src_step,
33 int len, int radius, float s)
35 const float length = radius*2 + 1;
36 const float inv = s / length;
38 float sum = src[radius*src_step];
39 for( x=0; x<radius; ++x )
40 sum += src[x*src_step]*2;
42 for( x=0; x<=radius; ++x ) {
43 sum += (src[(radius+x)*src_step] - src[(radius-x)*src_step])*inv;
44 dst[x*dst_step] = sum;
48 sum += (src[(radius+x)*src_step] - src[(x-radius-1)*src_step])*inv;
49 dst[x*dst_step] = sum;
51 for ( ; x<len; ++x ) {
52 sum += (src[(2*len-radius-x-1)*src_step] - src[(x-radius-1)*src_step])*inv;
53 dst[x*dst_step] = sum;
57 // s scales dst=src first pass
58 template<class dst_t, class src_t> static inline
59 void blur_power(dst_t *dst, int dst_step, src_t *src, int src_step,
60 int len, int radius, int power, float s)
62 dst_t atemp[len], btemp[len];
63 dst_t *a = atemp, *b = btemp;
64 blurt(a, 1, src, src_step, len, radius, s);
65 while( power-- > 2 ) {
66 blurt(b, 1, (const dst_t*)a, 1, len, radius, 1);
67 dst_t *t = a; a = b; b = t;
70 blurt(dst, dst_step, (const dst_t*)a, 1, len, radius, 1);
72 for( int i = 0; i<len; ++i ) dst[i*dst_step] = a[i];
76 BoxBlurPackage::BoxBlurPackage()
81 BoxBlurUnit::BoxBlurUnit(BoxBlur *box_blur)
82 : LoadClient(box_blur)
86 template<class dst_t, class src_t>
87 void BoxBlurUnit::blurt_package(LoadPackage *package)
89 BoxBlur *box_blur = (BoxBlur *)server;
90 src_t *src_data = (src_t *)box_blur->src_data;
91 dst_t *dst_data = (dst_t *)box_blur->dst_data;
92 int radius = box_blur->radius;
93 int power = box_blur->power;
94 int vlen = box_blur->vlen;
95 int c0 = box_blur->c0, c1 = box_blur->c1;
96 int src_ustep = box_blur->src_ustep;
97 int dst_ustep = box_blur->dst_ustep;
98 int src_vstep = box_blur->src_vstep;
99 int dst_vstep = box_blur->dst_vstep;
100 BoxBlurPackage *pkg = (BoxBlurPackage*)package;
101 int u1 = pkg->u1, u2 = pkg->u2, v = box_blur->v1;
103 if( sizeof(src_t) != sizeof(dst_t) ) {
104 switch( sizeof(dst_t) ) {
105 case 1: s = sizeof(src_t)==2 ? 1/256. : 255.; break;
106 case 2: s = sizeof(src_t)==1 ? 256. : 65535.; break;
107 case 4: s = sizeof(src_t)==1 ? 1/256. : 1/65535.; break;
110 for( int u=u1; u<u2; ++u ) {
111 src_t *sp = src_data + u*src_ustep + v*src_vstep;
112 dst_t *dp = dst_data + u*dst_ustep + v*dst_vstep;
113 for( int c=c0; c<=c1; ++c ) {
114 blur_power(dp+c, dst_vstep, sp+c, src_vstep,
115 vlen, radius, power, s);
120 void BoxBlurUnit::process_package(LoadPackage *package)
122 BoxBlur *box_blur = (BoxBlur *)server;
123 int src_bpc = box_blur->src_bpc, dst_bpc = box_blur->dst_bpc;
125 case 1: switch( dst_bpc ) {
126 case 1: blurt_package<uint8_t, const uint8_t>(package); break;
127 case 2: blurt_package<uint16_t, const uint8_t>(package); break;
128 case 4: blurt_package<float, const uint8_t>(package); break;
131 case 2: switch( dst_bpc ) {
132 case 1: blurt_package<uint8_t, const uint16_t>(package); break;
133 case 2: blurt_package<uint16_t, const uint16_t>(package); break;
134 case 4: blurt_package<float, const uint16_t>(package); break;
137 case 4: switch( dst_bpc ) {
138 case 1: blurt_package<uint8_t, const float>(package); break;
139 case 2: blurt_package<uint16_t, const float>(package); break;
140 case 4: blurt_package<float, const float>(package); break;
146 BoxBlur::BoxBlur(int cpus)
147 : LoadServer(cpus, cpus)
154 LoadClient* BoxBlur::new_client() { return new BoxBlurUnit(this); }
155 LoadPackage* BoxBlur::new_package() { return new BoxBlurPackage(); }
157 void BoxBlur::init_packages()
160 for( int i=0,n=LoadServer::get_total_packages(); i<n; ) {
161 BoxBlurPackage *pkg = (BoxBlurPackage*)get_package(i);
163 u = u1 + (++i * ulen) / n;
168 //dst can equal src, requires geom(dst)==geom(src)
169 //uv: 0=hblur, 1=vblur; comp: -1=rgb,0=r,1=g,2=b
170 void BoxBlur::process(VFrame *dst, VFrame *src, int uv,
171 int radius, int power, int comp)
173 this->radius = radius;
176 this->u1 = !uv ? y1 : x1;
177 this->u2 = !uv ? y2 : x2;
178 this->v1 = !uv ? x1 : y1;
179 this->v2 = !uv ? x2 : y2;
180 if( (ulen = u2 - u1) <= 0 ) return;
181 if( (vlen = v2 - v1) <= 0 ) return;
182 c0 = comp<0 ? 0 : comp;
183 c1 = comp<0 ? 2 : comp;
184 src_data = src->get_data();
185 dst_data = dst->get_data();
186 int src_pixsz = BC_CModels::calculate_pixelsize(src->get_color_model());
187 int src_comps = BC_CModels::components(src->get_color_model());
188 src_bpc = src_pixsz / src_comps;
189 int dst_pixsz = BC_CModels::calculate_pixelsize(dst->get_color_model());
190 int dst_comps = BC_CModels::components(dst->get_color_model());
191 dst_bpc = dst_pixsz / dst_comps;
192 int dst_linsz = dst->get_bytes_per_line() / dst_bpc;
193 int src_linsz = src->get_bytes_per_line() / src_bpc;
194 src_ustep = !uv ? src_linsz : src_comps;
195 dst_ustep = !uv ? dst_linsz : dst_comps;
196 src_vstep = !uv ? src_comps : src_linsz;
197 dst_vstep = !uv ? dst_comps : dst_linsz;
202 int BoxBlur::init_box(VFrame *dst, int x, int y, int w, int h)
208 int dw = dst->get_w(), dh = dst->get_h();
209 if( x2 > dw ) x2 = dw;
210 if( y2 > dh ) y2 = dh;
211 return x2 > x1 && y2 > y1 ? 1 : 0;
214 void BoxBlur::hblur(VFrame *dst, VFrame *src, int radius, int power, int comp,
215 int x, int y, int w, int h)
217 if( !init_box(dst, x, y, w, h) ) return;
218 process(dst, src, 0, radius, power, comp);
220 void BoxBlur::hblur(VFrame *dst, VFrame *src, int radius, int power, int comp)
222 return hblur(dst, src, radius, power, comp,
223 0, 0, dst->get_w(), dst->get_h());
226 void BoxBlur::vblur(VFrame *dst, VFrame *src, int radius, int power, int comp,
227 int x, int y, int w, int h)
229 if( !init_box(dst, x, y, w, h) ) return;
230 process(dst, src, 1, radius, power, comp);
232 void BoxBlur::vblur(VFrame *dst, VFrame *src, int radius, int power, int comp)
234 return vblur(dst, src, radius, power, comp,
235 0, 0, dst->get_w(), dst->get_h());
238 void BoxBlur::blur(VFrame *dst, VFrame *src, int radius, int power, int comp,
239 int x, int y, int w, int h)
241 if( !init_box(dst, x, y, w, h) ) return;
242 process(dst, src, 0, radius, power, comp);
243 process(dst, dst, 1, radius, power, comp);
245 void BoxBlur::blur(VFrame *dst, VFrame *src, int radius, int power, int comp)
247 return blur(dst, src, radius, power, comp,
248 0, 0, dst->get_w(), dst->get_h());