]> git.pld-linux.org Git - packages/framewave.git/blame_incremental - framewave-c++.patch
projects / packages / framewave.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
- - rebuild with boost 1.55.0
[packages/framewave.git] / framewave-c++.patch
... / ...
CommitLineData
1--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fe.h.orig 2009-07-09 11:15:40.000000000 +0200
2+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fe.h 2013-02-20 17:25:54.537266158 +0100
3@@ -1302,7 +1302,7 @@
4 {
5 protected:
6 // Algorithm instance
7- mutable FE &fe;
8+ FE &fe;
9 const U32 width;
10 const S32 s1Step, s2Step, s3Step,s4Step;
11 const S32 d1Step,d2Step,d3Step,d4Step;
12--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fex.h.orig 2009-07-09 11:15:40.000000000 +0200
13+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fex.h 2013-02-20 17:34:16.300578433 +0100
14@@ -119,7 +119,7 @@
15 class B0St
16 {
17 protected:
18- mutable FE &fe; // Algorithm instance
19+ FE &fe; // Algorithm instance
20 const U32 width;
21 const S32 s1Step, s2Step, s3Step,s4Step;
22 U32 threads;
23--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter_ProcessorTemplates.h.orig 2009-07-09 11:15:30.000000000 +0200
24+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter_ProcessorTemplates.h 2013-02-22 15:24:57.545866926 +0100
25@@ -52,7 +52,7 @@
26 while( pDstElement < pLineEnd )
27 {
28 // perform the pixel calculations
29- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
30+ TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
31 pSrcElement++;
32 pDstElement++;
33 }
34@@ -101,9 +101,9 @@
35 // iterate through the destination data from left to right
36 while( pDstElement < pLineEnd )
37 {
38- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
39- Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep );
40- Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep );
41+ TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
42+ TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep );
43+ TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep );
44 pSrcElement += 4;
45 pDstElement += 4;
46 }
47@@ -151,7 +151,7 @@
48 // iterate through the destination data from left to right
49 while( pDstElement < pLineEnd )
50 {
51- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
52+ TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
53 pSrcElement++;
54 pDstElement++;
55 }
56@@ -200,9 +200,9 @@
57 // iterate through the destination data from left to right
58 while( pDstElement < pLineEnd )
59 {
60- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
61- Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor );
62- Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor );
63+ TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
64+ TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor );
65+ TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor );
66 pSrcElement += 4;
67 pDstElement += 4;
68 }
69@@ -250,7 +250,7 @@
70 // iterate through the destination data from left to right
71 while( pDstElement < pLineEnd )
72 {
73- Calculate( pSrcElement, pData->srcStep,
74+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement, pData->srcStep,
75 pDstElement, pData->dstStep,
76 (const Fw32s *)pData->pKernel, pData->kernelSize,
77 pData->anchor, pData->divisor );
78@@ -302,15 +302,15 @@
79 // iterate through the destination data from left to right
80 while( pDstElement < pLineEnd )
81 {
82- Calculate( pSrcElement, pData->srcStep,
83+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement, pData->srcStep,
84 pDstElement, pData->dstStep,
85 (const Fw32s *)pData->pKernel, pData->kernelSize,
86 pData->anchor, pData->divisor );
87- Calculate( pSrcElement+1, pData->srcStep,
88+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement+1, pData->srcStep,
89 pDstElement+1, pData->dstStep,
90 (const Fw32s *)pData->pKernel, pData->kernelSize,
91 pData->anchor, pData->divisor );
92- Calculate( pSrcElement+2, pData->srcStep,
93+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement+2, pData->srcStep,
94 pDstElement+2, pData->dstStep,
95 (const Fw32s *)pData->pKernel, pData->kernelSize,
96 pData->anchor, pData->divisor );
97@@ -361,7 +361,7 @@
98 // iterate through the destination data from left to right
99 while( pDstElement < pLineEnd )
100 {
101- Calculate( pSrcElement, pData->srcStep,
102+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement, pData->srcStep,
103 pDstElement, pData->dstStep,
104 (const Fw32f *)pData->pKernel, pData->kernelSize,
105 pData->anchor );
106@@ -413,15 +413,15 @@
107 // iterate through the destination data from left to right
108 while( pDstElement < pLineEnd )
109 {
110- Calculate( pSrcElement, pData->srcStep,
111+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement, pData->srcStep,
112 pDstElement, pData->dstStep,
113 (const Fw32f *)pData->pKernel, pData->kernelSize,
114 pData->anchor );
115- Calculate( pSrcElement+1, pData->srcStep,
116+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement+1, pData->srcStep,
117 pDstElement+1, pData->dstStep,
118 (const Fw32f *)pData->pKernel, pData->kernelSize,
119 pData->anchor );
120- Calculate( pSrcElement+2, pData->srcStep,
121+ TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement+2, pData->srcStep,
122 pDstElement+2, pData->dstStep,
123 (const Fw32f *)pData->pKernel, pData->kernelSize,
124 pData->anchor );
125@@ -471,7 +471,7 @@
126 DstType *pLineEnd = pDstElement + pData->dstRoiSize.width * chCount;
127 while( pDstElement < pLineEnd )
128 {
129- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
130+ TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
131 pSrcElement++;
132 pDstElement++;
133 }
134@@ -520,9 +520,9 @@
135 // iterate through the destination data from left to right
136 while( pDstElement < pLineEnd )
137 {
138- Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
139- Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
140- Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
141+ TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
142+ TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
143+ TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
144 *(pDstElement+3) = *(pSrcElement+3);
145 pSrcElement += 4;
146 pDstElement += 4;
147@@ -571,7 +571,7 @@
148 // iterate through the destination data from left to right
149 while( pDstElement < pLineEnd )
150 {
151- CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
152+ TProcessorAllChannels_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
153 pSrcElement += chCount;
154 pDstElement += chCount;
155 }
156@@ -620,7 +620,7 @@
157 // iterate through the destination data from left to right
158 while( pDstElement < pLineEnd )
159 {
160- CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
161+ TProcessorAllChannels_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
162 pSrcElement += 4;
163 pDstElement += 4;
164 }
165@@ -668,7 +668,7 @@
166 // iterate through the destination data from left to right
167 while( pDstElement < pLineEnd )
168 {
169- CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
170+ TProcessorAllChannelsWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
171 pSrcElement += chCount;
172 pDstElement += chCount;
173 }
174@@ -717,7 +717,7 @@
175 // iterate through the destination data from left to right
176 while( pDstElement < pLineEnd )
177 {
178- CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
179+ TProcessorAllChannelsWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
180 pSrcElement += 4;
181 pDstElement += 4;
182 }
183@@ -773,7 +773,7 @@
184 DstType * pDstElement = pDst;
185 for( int col = 0; col < pData->dstRoiSize.width * chCount; col++ )
186 {
187- Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
188+ TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
189 pDstElement++;
190 }
191 pDst = FW_REF::Offset(pDst, pData->dstStep);
192@@ -820,9 +820,9 @@
193 DstType * pDstElement = pDst;
194 for( int col = 0; col < pData->dstRoiSize.width * AC4; )
195 {
196- Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
197- Calculate( borderBufferObj, col+1, pDstElement+1, pData->maskSize, pData->anchor );
198- Calculate( borderBufferObj, col+2, pDstElement+2, pData->maskSize, pData->anchor );
199+ TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
200+ TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col+1, pDstElement+1, pData->maskSize, pData->anchor );
201+ TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col+2, pDstElement+2, pData->maskSize, pData->anchor );
202 pDstElement+=4;
203 col+=4;
204 }
205@@ -901,7 +901,7 @@
206 {
207 // at the beginning of each row start by calling the generic Calculate method that does
208 // not reuse any previous calculations
209- Calculate( pSrc, pData->srcStep,
210+ TProcessor_ZigZagRDRD::Calculate( pSrc, pData->srcStep,
211 pDst, pData->dstStep,
212 pData->maskSize,
213 pData->anchor,
214@@ -915,7 +915,7 @@
215 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
216 while( pDstElement < pLineEnd )
217 {
218- CalculateRight( pSrcElement, pData->srcStep,
219+ TProcessor_ZigZagRDRD::CalculateRight( pSrcElement, pData->srcStep,
220 pDstElement, pData->dstStep,
221 pData->maskSize,
222 pData->anchor,
223@@ -963,7 +963,7 @@
224 {
225 // at the beginning of each row start by calling the generic Calculate method that does
226 // not reuse any previous calculations
227- Calculate( pSrc, pData->srcStep,
228+ TProcessor_ZigZagRDRD::Calculate( pSrc, pData->srcStep,
229 pDst, pData->dstStep,
230 pData->maskSize,
231 pData->anchor,
232@@ -977,7 +977,7 @@
233 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
234 while( pDstElement < pLineEnd )
235 {
236- CalculateRight( pSrcElement, pData->srcStep,
237+ TProcessor_ZigZagRDRD::CalculateRight( pSrcElement, pData->srcStep,
238 pDstElement, pData->dstStep,
239 pData->maskSize,
240 pData->anchor,
241@@ -1038,7 +1038,7 @@
242 while( pDst < pEndDst )
243 {
244 // at the top of each column call the generic Calculate method
245- Calculate( pSrc, pData->srcStep,
246+ TProcessor_ZigZagDRDR::Calculate( pSrc, pData->srcStep,
247 pDst, pData->dstStep,
248 pData->maskSize,
249 pData->anchor,
250@@ -1052,7 +1052,7 @@
251 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
252 while( pDstElement < pColumnEnd )
253 {
254- CalculateDown( pSrcElement, pData->srcStep,
255+ TProcessor_ZigZagDRDR::CalculateDown( pSrcElement, pData->srcStep,
256 pDstElement, pData->dstStep,
257 pData->maskSize,
258 pData->anchor,
259@@ -1100,7 +1100,7 @@
260 while( pDst < pEndDst )
261 {
262 // at the top of each column call the generic Calculate method
263- Calculate( pSrc, pData->srcStep,
264+ TProcessor_ZigZagDRDR::Calculate( pSrc, pData->srcStep,
265 pDst, pData->dstStep,
266 pData->maskSize,
267 pData->anchor,
268@@ -1114,7 +1114,7 @@
269 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
270 while( pDstElement < pColumnEnd )
271 {
272- CalculateDown( pSrcElement, pData->srcStep,
273+ TProcessor_ZigZagDRDR::CalculateDown( pSrcElement, pData->srcStep,
274 pDstElement, pData->dstStep,
275 pData->maskSize,
276 pData->anchor,
277@@ -1175,7 +1175,7 @@
278 DstType * pEndDst = FW_REF::Offset( pData->pDst, pData->dstRoiSize.height * pData->dstStep );
279
280 // start in the top left corner of the image
281- Calculate( pSrc, pData->srcStep,
282+ TProcessor_ZigZagRDLD::Calculate( pSrc, pData->srcStep,
283 pDst, pData->dstStep,
284 pData->maskSize,
285 pData->anchor,
286@@ -1193,7 +1193,7 @@
287 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
288 while( pDstElement < pLineEnd )
289 {
290- CalculateRight( pSrcElement, pData->srcStep,
291+ TProcessor_ZigZagRDLD::CalculateRight( pSrcElement, pData->srcStep,
292 pDstElement, pData->dstStep,
293 pData->maskSize,
294 pData->anchor,
295@@ -1208,7 +1208,7 @@
296 if( pDstElement >= pEndDst )
297 break;
298
299- CalculateDown( pSrcElement, pData->srcStep,
300+ TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
301 pDstElement, pData->dstStep,
302 pData->maskSize,
303 pData->anchor,
304@@ -1226,7 +1226,7 @@
305
306 while( pDstElement >= pDst )
307 {
308- CalculateLeft( pSrcElement, pData->srcStep,
309+ TProcessor_ZigZagRDLD::CalculateLeft( pSrcElement, pData->srcStep,
310 pDstElement, pData->dstStep,
311 pData->maskSize,
312 pData->anchor,
313@@ -1244,7 +1244,7 @@
314 if( pDst >= pEndDst )
315 break;
316
317- CalculateDown( pSrcElement, pData->srcStep,
318+ TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
319 pDstElement, pData->dstStep,
320 pData->maskSize,
321 pData->anchor,
322@@ -1282,7 +1282,7 @@
323 // calculate the pointer to the end of the destination data
324 DstType * pEndDst = FW_REF::Offset( pData->pDst, pData->dstRoiSize.height * pData->dstStep );
325
326- Calculate( pSrc, pData->srcStep,
327+ TProcessor_ZigZagRDLD::Calculate( pSrc, pData->srcStep,
328 pDst, pData->dstStep,
329 pData->maskSize,
330 pData->anchor,
331@@ -1295,7 +1295,7 @@
332 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
333 while( pDstElement < pLineEnd )
334 {
335- CalculateRight( pSrcElement, pData->srcStep,
336+ TProcessor_ZigZagRDLD::CalculateRight( pSrcElement, pData->srcStep,
337 pDstElement, pData->dstStep,
338 pData->maskSize,
339 pData->anchor,
340@@ -1308,7 +1308,7 @@
341 if( pDstElement >= pEndDst )
342 break;
343
344- CalculateDown( pSrcElement, pData->srcStep,
345+ TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
346 pDstElement, pData->dstStep,
347 pData->maskSize,
348 pData->anchor,
349@@ -1320,7 +1320,7 @@
350
351 while( pDstElement >= pDst )
352 {
353- CalculateLeft( pSrcElement, pData->srcStep,
354+ TProcessor_ZigZagRDLD::CalculateLeft( pSrcElement, pData->srcStep,
355 pDstElement, pData->dstStep,
356 pData->maskSize,
357 pData->anchor,
358@@ -1336,7 +1336,7 @@
359 if( pDst >= pEndDst )
360 break;
361
362- CalculateDown( pSrcElement, pData->srcStep,
363+ TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
364 pDstElement, pData->dstStep,
365 pData->maskSize,
366 pData->anchor,
367@@ -1391,7 +1391,7 @@
368 DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
369
370 // start in the top left corner
371- Calculate( pSrc, pData->srcStep,
372+ TProcessor_ZigZagDRUR::Calculate( pSrc, pData->srcStep,
373 pDst, pData->dstStep,
374 pData->maskSize,
375 pData->anchor,
376@@ -1407,7 +1407,7 @@
377 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
378 while( pDstElement < pColumnEnd )
379 {
380- CalculateDown( pSrcElement, pData->srcStep,
381+ TProcessor_ZigZagDRUR::CalculateDown( pSrcElement, pData->srcStep,
382 pDstElement, pData->dstStep,
383 pData->maskSize,
384 pData->anchor,
385@@ -1421,7 +1421,7 @@
386 if( pDstElement >= pEndDst2 )
387 break;
388
389- CalculateRight( pSrcElement, pData->srcStep,
390+ TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
391 pDstElement, pData->dstStep,
392 pData->maskSize,
393 pData->anchor,
394@@ -1436,7 +1436,7 @@
395
396 while( pDstElement >= pDst )
397 {
398- CalculateUp( pSrcElement, pData->srcStep,
399+ TProcessor_ZigZagDRUR::CalculateUp( pSrcElement, pData->srcStep,
400 pDstElement, pData->dstStep,
401 pData->maskSize,
402 pData->anchor,
403@@ -1453,7 +1453,7 @@
404 if( pDst >= pEndDst )
405 break;
406
407- CalculateRight( pSrcElement, pData->srcStep,
408+ TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
409 pDstElement, pData->dstStep,
410 pData->maskSize,
411 pData->anchor,
412@@ -1493,7 +1493,7 @@
413 DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
414
415 // start in the top left corner
416- Calculate( pSrc, pData->srcStep,
417+ TProcessor_ZigZagDRUR::Calculate( pSrc, pData->srcStep,
418 pDst, pData->dstStep,
419 pData->maskSize,
420 pData->anchor,
421@@ -1509,7 +1509,7 @@
422 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
423 while( pDstElement < pColumnEnd )
424 {
425- CalculateDown( pSrcElement, pData->srcStep,
426+ TProcessor_ZigZagDRUR::CalculateDown( pSrcElement, pData->srcStep,
427 pDstElement, pData->dstStep,
428 pData->maskSize,
429 pData->anchor,
430@@ -1524,7 +1524,7 @@
431 if( pDstElement >= pEndDst2 )
432 break;
433
434- CalculateRight( pSrcElement, pData->srcStep,
435+ TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
436 pDstElement, pData->dstStep,
437 pData->maskSize,
438 pData->anchor,
439@@ -1540,7 +1540,7 @@
440
441 while( pDstElement >= pDst )
442 {
443- CalculateUp( pSrcElement, pData->srcStep,
444+ TProcessor_ZigZagDRUR::CalculateUp( pSrcElement, pData->srcStep,
445 pDstElement, pData->dstStep,
446 pData->maskSize,
447 pData->anchor,
448@@ -1558,7 +1558,7 @@
449 if( pDst >= pEndDst )
450 break;
451
452- CalculateRight( pSrcElement, pData->srcStep,
453+ TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
454 pDstElement, pData->dstStep,
455 pData->maskSize,
456 pData->anchor,
457--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterGeneral.cpp.orig 2009-07-09 11:15:34.000000000 +0200
458+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterGeneral.cpp 2013-02-22 15:44:44.933889396 +0100
459@@ -125,7 +125,7 @@
460 zero.i = _mm_setzero_si128();
461
462 XMM128 divisor_inv;
463- GetDivisorInv( divisor_inv, pData->divisor );
464+ FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
465
466 // calculate destination mask for the 4 channel with alpha scenario
467 XMM128 alphaMask;
468@@ -178,17 +178,17 @@
469 case C1:
470 case C3:
471 case C4:
472- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
473+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
474 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
475 pd++;
476 ps++;
477 break;
478 case AC4:
479- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
480+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
481 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
482- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
483+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
484 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
485- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
486+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
487 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
488 pd += 4;
489 ps += 4;
490@@ -201,7 +201,7 @@
491 /////////////////////////////////////////////////////////////////
492 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) ) // Process 1 horizontal line (16 wide)
493 {
494- SSE2_Aligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
495+ FilterProcessor_superclass::SSE2_Aligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
496 }
497
498 /////////////////////////////////////////////////////////////////
499@@ -214,17 +214,17 @@
500 case C1:
501 case C3:
502 case C4:
503- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
504+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
505 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
506 pd++;
507 ps++;
508 break;
509 case AC4:
510- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
511+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
512 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
513- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
514+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
515 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
516- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
517+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
518 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
519 pd += 4;
520 ps += 4;
521@@ -258,7 +258,7 @@
522 zero.i = _mm_setzero_si128();
523
524 XMM128 divisor_inv;
525- GetDivisorInv( divisor_inv, pData->divisor );
526+ FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
527
528 XMM128 alphaMask;
529 if( chCount == AC4 )
530@@ -301,7 +301,7 @@
531 /////////////////////////////////////////////////////////////////
532 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) ) // Process 1 horizontal line (16 wide)
533 {
534- SSE2_Unaligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
535+ FilterProcessor_superclass::SSE2_Unaligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
536 }
537
538 /////////////////////////////////////////////////////////////////
539@@ -314,17 +314,17 @@
540 case C1:
541 case C3:
542 case C4:
543- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
544+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
545 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
546 pd++;
547 ps++;
548 break;
549 case AC4:
550- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
551+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
552 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
553- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
554+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
555 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
556- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
557+ FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
558 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
559 pd += 4;
560 ps += 4;
561@@ -425,17 +425,17 @@
562 case C1:
563 case C3:
564 case C4:
565- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
566+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
567 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
568 pd++;
569 ps++;
570 break;
571 case AC4:
572- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
573+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
574 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
575- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
576+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
577 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
578- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
579+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
580 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
581 pd += 4;
582 ps += 4;
583@@ -448,7 +448,7 @@
584 /////////////////////////////////////////////////////////////////
585 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) ) // Process 1 horizontal line (16 wide)
586 {
587- SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
588+ FilterProcessor_NoDivision_superclass::SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
589 }
590
591 /////////////////////////////////////////////////////////////////
592@@ -461,17 +461,17 @@
593 case C1:
594 case C3:
595 case C4:
596- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
597+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
598 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
599 pd++;
600 ps++;
601 break;
602 case AC4:
603- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
604+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
605 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
606- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
607+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
608 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
609- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
610+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
611 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
612 pd += 4;
613 ps += 4;
614@@ -546,7 +546,7 @@
615 /////////////////////////////////////////////////////////////////
616 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) ) // Process 1 horizontal line (16 wide)
617 {
618- SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
619+ FilterProcessor_NoDivision_superclass::SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
620 }
621
622 /////////////////////////////////////////////////////////////////
623@@ -559,17 +559,17 @@
624 case C1:
625 case C3:
626 case C4:
627- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
628+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
629 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
630 pd++;
631 ps++;
632 break;
633 case AC4:
634- Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
635+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
636 pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
637- Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
638+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
639 pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
640- Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
641+ FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
642 pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
643 pd += 4;
644 ps += 4;
645--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterSeparable.cpp.orig 2009-07-09 11:15:34.000000000 +0200
646+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterSeparable.cpp 2013-02-22 16:02:53.624049208 +0100
647@@ -396,7 +396,7 @@
648 // process the unaligned "prefix" data (up to 15 bytes)
649 /////////////////////////////////////////////////////////////////
650 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
651- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
652+ FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
653
654 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
655 {
656@@ -529,7 +529,7 @@
657 /////////////////////////////////////////////////////////////////
658
659 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
660- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
661+ FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
662
663 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
664 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
665@@ -701,7 +701,7 @@
666 /////////////////////////////////////////////////////////////////
667
668 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
669- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
670+ FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
671
672 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
673 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
674@@ -767,7 +767,7 @@
675 // process the unaligned "prefix" data (up to 15 bytes)
676 /////////////////////////////////////////////////////////////////
677 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
678- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
679+ FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
680
681 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
682 {
683@@ -853,7 +853,7 @@
684 /////////////////////////////////////////////////////////////////
685
686 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
687- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
688+ FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
689
690 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
691 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
692@@ -979,7 +979,7 @@
693 /////////////////////////////////////////////////////////////////
694
695 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
696- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
697+ FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
698
699 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
700 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
701@@ -1045,7 +1045,7 @@
702 // process the unaligned "prefix" data (up to 15 bytes)
703 /////////////////////////////////////////////////////////////////
704 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
705- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
706+ FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
707
708 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
709 {
710@@ -1096,7 +1096,7 @@
711 /////////////////////////////////////////////////////////////////
712
713 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
714- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
715+ FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
716
717 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
718 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
719@@ -1187,7 +1187,7 @@
720 /////////////////////////////////////////////////////////////////
721
722 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
723- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
724+ FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
725
726 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
727 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
728@@ -1253,7 +1253,7 @@
729 // process the unaligned "prefix" data (up to 15 bytes)
730 /////////////////////////////////////////////////////////////////
731 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
732- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
733+ FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
734
735 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
736 {
737@@ -1300,7 +1300,7 @@
738 /////////////////////////////////////////////////////////////////
739
740 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
741- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
742+ FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
743
744 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
745 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
746@@ -1386,7 +1386,7 @@
747 /////////////////////////////////////////////////////////////////
748
749 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
750- Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
751+ FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
752
753 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
754 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
755@@ -1516,7 +1516,7 @@
756 // process the unaligned "prefix" data (up to 15 bytes)
757 /////////////////////////////////////////////////////////////////
758 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
759- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
760+ FilterRowProcessor::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
761
762 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
763 {
764@@ -1646,7 +1646,7 @@
765 /////////////////////////////////////////////////////////////////
766
767 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
768- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
769+ FilterRowProcessor::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
770
771 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
772 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
773@@ -1709,7 +1709,7 @@
774 // process the unaligned "prefix" data (up to 15 bytes)
775 /////////////////////////////////////////////////////////////////
776 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
777- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
778+ FilterRowProcessor_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
779
780 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
781 {
782@@ -1796,7 +1796,7 @@
783 /////////////////////////////////////////////////////////////////
784
785 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
786- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
787+ FilterRowProcessor_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
788
789 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
790 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
791@@ -1864,7 +1864,7 @@
792 // process the unaligned "prefix" data (up to 15 bytes)
793 /////////////////////////////////////////////////////////////////
794 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
795- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
796+ FilterRowProcessor_5_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
797
798 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
799 {
800@@ -2034,7 +2034,7 @@
801 /////////////////////////////////////////////////////////////////
802
803 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
804- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
805+ FilterRowProcessor_5_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
806
807 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
808 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
809@@ -2101,7 +2101,7 @@
810 // process the unaligned "prefix" data (up to 15 bytes)
811 /////////////////////////////////////////////////////////////////
812 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
813- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
814+ FilterRowProcessor_5_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
815
816 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
817 {
818@@ -2195,7 +2195,7 @@
819 /////////////////////////////////////////////////////////////////
820
821 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
822- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
823+ FilterRowProcessor_5_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
824
825 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
826 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
827@@ -2262,7 +2262,7 @@
828 // process the unaligned "prefix" data (up to 15 bytes)
829 /////////////////////////////////////////////////////////////////
830 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
831- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
832+ FilterRowProcessor_5_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
833
834 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
835 {
836@@ -2353,7 +2353,7 @@
837 /////////////////////////////////////////////////////////////////
838
839 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
840- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
841+ FilterRowProcessor_5_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
842
843 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
844 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
845@@ -2421,7 +2421,7 @@
846 // process the unaligned "prefix" data (up to 15 bytes)
847 /////////////////////////////////////////////////////////////////
848 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
849- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
850+ FilterRowProcessor_3_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
851
852 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
853 {
854@@ -2535,7 +2535,7 @@
855 /////////////////////////////////////////////////////////////////
856
857 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
858- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
859+ FilterRowProcessor_3_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
860
861 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
862 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
863@@ -2602,7 +2602,7 @@
864 // process the unaligned "prefix" data (up to 15 bytes)
865 /////////////////////////////////////////////////////////////////
866 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
867- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
868+ FilterRowProcessor_3_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
869
870 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
871 {
872@@ -2666,7 +2666,7 @@
873 /////////////////////////////////////////////////////////////////
874
875 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
876- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
877+ FilterRowProcessor_3_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
878
879 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
880 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
881@@ -2733,7 +2733,7 @@
882 // process the unaligned "prefix" data (up to 15 bytes)
883 /////////////////////////////////////////////////////////////////
884 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
885- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
886+ FilterRowProcessor_3_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
887
888 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
889 {
890@@ -2794,7 +2794,7 @@
891 /////////////////////////////////////////////////////////////////
892
893 for( ; pd<pEnd; ++pd, ++ps ) // Process the remainder.
894- Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
895+ FilterRowProcessor_3_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
896
897 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
898 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
899--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterMedian.cpp.orig 2009-07-09 11:15:34.000000000 +0200
900+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterMedian.cpp 2013-02-22 18:19:46.216893594 +0100
901@@ -98,7 +98,7 @@
902 {
903 *(pSortedList + nSortedListLength * channel + nListLength[channel]) = *pElement;
904 nListLength[channel]++;
905- OnePassSort( pSortedList + nSortedListLength * channel, nListLength[channel], nListLength[channel] - 1 );
906+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nListLength[channel], nListLength[channel] - 1 );
907 pElement++;
908 channel = ( channel + 1 ) % chCount;
909 }
910@@ -130,9 +130,9 @@
911 int channel = 0;
912 while( pOldElement < LastElement )
913 {
914- int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
915+ int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
916 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
917- OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
918+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
919
920 channel = ( channel + 1 ) % chCount;
921 pOldElement++;
922@@ -167,9 +167,9 @@
923 int channel = 0;
924 while( pOldElement < LastElement )
925 {
926- int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
927+ int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
928 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
929- OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
930+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
931
932 channel = ( channel + 1 ) % chCount;
933 pOldElement++;
934@@ -201,9 +201,9 @@
935 int channel = 0;
936 while( pOldElement < LastElement )
937 {
938- int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
939+ int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
940 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
941- OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
942+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
943
944 channel = ( channel + 1 ) % chCount;
945 pOldElement++;
946@@ -233,9 +233,9 @@
947 int channel = 0;
948 while( pOldElement < LastElement )
949 {
950- int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
951+ int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
952 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
953- OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
954+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
955
956 channel = ( channel + 1 ) % chCount;
957 pOldElement++;
958@@ -281,9 +281,9 @@
959 *(pSortedList + nSortedListLength * 1 + nListLength) = *(pElement+1);
960 *(pSortedList + nSortedListLength * 2 + nListLength) = *(pElement+2);
961 nListLength++;
962- OnePassSort( pSortedList + nSortedListLength * 0, nListLength, nListLength - 1 );
963- OnePassSort( pSortedList + nSortedListLength * 1, nListLength, nListLength - 1 );
964- OnePassSort( pSortedList + nSortedListLength * 2, nListLength, nListLength - 1 );
965+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nListLength, nListLength - 1 );
966+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nListLength, nListLength - 1 );
967+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nListLength, nListLength - 1 );
968 pElement += C4;
969 }
970 pSrc = (SrcType*)(((Fw8u*)(pSrc)) + srcstep);
971@@ -312,19 +312,19 @@
972 int nOldIndex;
973
974 // red channel
975- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
976+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
977 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
978- OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
979+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
980
981 // green channel
982- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
983+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
984 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
985- OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
986+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
987
988 // blue channel
989- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
990+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
991 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
992- OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
993+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
994
995 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
996 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
997@@ -352,19 +352,19 @@
998 while( pOldElement < pEnd )
999 {
1000 // red channel
1001- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1002+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1003 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
1004- OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1005+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1006
1007 // green channel
1008- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1009+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1010 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
1011- OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1012+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1013
1014 // blue channel
1015- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1016+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1017 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
1018- OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1019+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1020
1021 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
1022 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
1023@@ -391,17 +391,17 @@
1024 int nOldIndex;
1025 while( pOldElement < LastElement )
1026 {
1027- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1028+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1029 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
1030- OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1031+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1032
1033- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1034+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1035 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
1036- OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1037+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1038
1039- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1040+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1041 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
1042- OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1043+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1044
1045 pOldElement+=4;
1046 pNewElement+=4;
1047@@ -428,17 +428,17 @@
1048 int nOldIndex;
1049 while( pOldElement < LastElement )
1050 {
1051- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1052+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
1053 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
1054- OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1055+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
1056
1057- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1058+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
1059 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
1060- OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1061+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
1062
1063- nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1064+ nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
1065 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
1066- OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1067+ FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
1068
1069 pOldElement+=4;
1070 pNewElement+=4;
1071@@ -476,7 +476,7 @@
1072 for( int channel = 0; channel < chCount; channel++ )
1073 {
1074 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1075- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1076+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1077 }
1078 nListLength++;
1079 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
1080@@ -489,7 +489,7 @@
1081 for( int channel = 0; channel < chCount; channel++ )
1082 {
1083 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1084- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1085+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1086 }
1087 nListLength++;
1088 pElement += chCount;
1089@@ -501,7 +501,7 @@
1090 for( int channel = 0; channel < chCount; channel++ )
1091 {
1092 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1093- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1094+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1095 }
1096 nListLength++;
1097 pElement += chCount;
1098@@ -541,7 +541,7 @@
1099 for( int channel = 0; channel < C3; channel++ )
1100 {
1101 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1102- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1103+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1104 }
1105 nListLength++;
1106 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
1107@@ -554,7 +554,7 @@
1108 for( int channel = 0; channel < C3; channel++ )
1109 {
1110 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1111- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1112+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1113 }
1114 nListLength++;
1115 pElement += chCount;
1116@@ -566,7 +566,7 @@
1117 for( int channel = 0; channel < C3; channel++ )
1118 {
1119 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1120- OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1121+ FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1122 }
1123 nListLength++;
1124 pElement += chCount;
1125@@ -603,45 +603,45 @@
1126 const SrcType * pSrcAbove = (const SrcType *)(((Fw8u*)pSrcPtr) - srcstep);
1127 const SrcType * pSrcBelow = (const SrcType *)(((Fw8u*)pSrcPtr) + srcstep);
1128 const SrcType * pMinPtr = pSrcPtr - chCount;
1129- minDist = Distance( pSrcPtr, pMinPtr );
1130+ minDist = FilterMedianColor3x3::Distance( pSrcPtr, pMinPtr );
1131
1132- tempDist = Distance( pSrcPtr, pSrcPtr + chCount );
1133+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcPtr + chCount );
1134 if( tempDist < minDist )
1135 {
1136 pMinPtr = pSrcPtr + chCount;
1137 minDist = tempDist;
1138 }
1139- tempDist = Distance( pSrcPtr, pSrcAbove - chCount );
1140+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove - chCount );
1141 if( tempDist < minDist )
1142 {
1143 pMinPtr = pSrcAbove - chCount;
1144 minDist = tempDist;
1145 }
1146- tempDist = Distance( pSrcPtr, pSrcAbove );
1147+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove );
1148 if( tempDist < minDist )
1149 {
1150 pMinPtr = pSrcAbove;
1151 minDist = tempDist;
1152 }
1153- tempDist = Distance( pSrcPtr, pSrcAbove + chCount );
1154+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove + chCount );
1155 if( tempDist < minDist )
1156 {
1157 pMinPtr = pSrcAbove + chCount;
1158 minDist = tempDist;
1159 }
1160- tempDist = Distance( pSrcPtr, pSrcBelow - chCount );
1161+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow - chCount );
1162 if( tempDist < minDist )
1163 {
1164 pMinPtr = pSrcBelow - chCount;
1165 minDist = tempDist;
1166 }
1167- tempDist = Distance( pSrcPtr, pSrcBelow );
1168+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow );
1169 if( tempDist < minDist )
1170 {
1171 pMinPtr = pSrcBelow;
1172 minDist = tempDist;
1173 }
1174- tempDist = Distance( pSrcPtr, pSrcBelow + chCount );
1175+ tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow + chCount );
1176 if( tempDist < minDist )
1177 {
1178 pMinPtr = pSrcBelow + chCount;
1179@@ -656,7 +656,7 @@
1180 const FwiPoint & /*anchor*/ )
1181 {
1182 CalcType minDist;
1183- const SrcType * pMinPtr = FindMinimum3x3( pSrcPtr, srcstep, minDist );
1184+ const SrcType * pMinPtr = FilterMedianColor3x3::FindMinimum3x3( pSrcPtr, srcstep, minDist );
1185 *(pDst+0) = *(pMinPtr+0);
1186 *(pDst+1) = *(pMinPtr+1);
1187 *(pDst+2) = *(pMinPtr+2);
1188@@ -674,99 +674,99 @@
1189 const SrcType * pSrcBelow = (const SrcType *)(((Fw8u*)pSrcPtr) + srcstep);
1190 const SrcType * pSrcBelow2 = (const SrcType *)(((Fw8u*)pSrcPtr) + 2 * srcstep);
1191
1192- const SrcType * pMinPtr = FindMinimum3x3( pSrcPtr, srcstep, minDist );
1193+ const SrcType * pMinPtr = FilterMedianColor5x5::FindMinimum3x3( pSrcPtr, srcstep, minDist );
1194
1195- tempDist = Distance( pSrcPtr, pSrcPtr - chCount * 2 );
1196+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr - chCount * 2 );
1197 if( tempDist < minDist )
1198 {
1199 pMinPtr = pSrcPtr - chCount * 2;
1200 minDist = tempDist;
1201 }
1202- tempDist = Distance( pSrcPtr, pSrcPtr + chCount * 2 );
1203+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr + chCount * 2 );
1204 if( tempDist < minDist )
1205 {
1206 pMinPtr = pSrcPtr + chCount * 2;
1207 minDist = tempDist;
1208 }
1209- tempDist = Distance( pSrcPtr, pSrcAbove - chCount * 2 );
1210+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove - chCount * 2 );
1211 if( tempDist < minDist )
1212 {
1213 pMinPtr = pSrcAbove - chCount * 2;
1214 minDist = tempDist;
1215 }
1216- tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
1217+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
1218 if( tempDist < minDist )
1219 {
1220 pMinPtr = pSrcAbove2 - chCount * 2;
1221 minDist = tempDist;
1222 }
1223- tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount );
1224+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount );
1225 if( tempDist < minDist )
1226 {
1227 pMinPtr = pSrcAbove2 - chCount;
1228 minDist = tempDist;
1229 }
1230- tempDist = Distance( pSrcPtr, pSrcAbove2 );
1231+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 );
1232 if( tempDist < minDist )
1233 {
1234 pMinPtr = pSrcAbove2;
1235 minDist = tempDist;
1236 }
1237- tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount );
1238+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount );
1239 if( tempDist < minDist )
1240 {
1241 pMinPtr = pSrcAbove2 + chCount;
1242 minDist = tempDist;
1243 }
1244- tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
1245+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
1246 if( tempDist < minDist )
1247 {
1248 pMinPtr = pSrcAbove2 + chCount * 2;
1249 minDist = tempDist;
1250 }
1251- tempDist = Distance( pSrcPtr, pSrcAbove + chCount * 2 );
1252+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove + chCount * 2 );
1253 if( tempDist < minDist )
1254 {
1255 pMinPtr = pSrcAbove + chCount * 2;
1256 minDist = tempDist;
1257 }
1258- tempDist = Distance( pSrcPtr, pSrcBelow - chCount * 2 );
1259+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow - chCount * 2 );
1260 if( tempDist < minDist )
1261 {
1262 pMinPtr = pSrcBelow - chCount * 2;
1263 minDist = tempDist;
1264 }
1265- tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
1266+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
1267 if( tempDist < minDist )
1268 {
1269 pMinPtr = pSrcBelow2 - chCount * 2;
1270 minDist = tempDist;
1271 }
1272- tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount );
1273+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount );
1274 if( tempDist < minDist )
1275 {
1276 pMinPtr = pSrcBelow2 - chCount;
1277 minDist = tempDist;
1278 }
1279- tempDist = Distance( pSrcPtr, pSrcBelow2 );
1280+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 );
1281 if( tempDist < minDist )
1282 {
1283 pMinPtr = pSrcBelow2;
1284 minDist = tempDist;
1285 }
1286- tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount );
1287+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount );
1288 if( tempDist < minDist )
1289 {
1290 pMinPtr = pSrcBelow2 + chCount;
1291 minDist = tempDist;
1292 }
1293- tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
1294+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
1295 if( tempDist < minDist )
1296 {
1297 pMinPtr = pSrcBelow2 + chCount * 2;
1298 minDist = tempDist;
1299 }
1300- tempDist = Distance( pSrcPtr, pSrcBelow + chCount * 2 );
1301+ tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow + chCount * 2 );
1302 if( tempDist < minDist )
1303 {
1304 pMinPtr = pSrcBelow + chCount * 2;
1305--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/Arithmetic/Impl/DivImpl.h.orig 2009-07-09 11:15:36.000000000 +0200
1306+++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/Arithmetic/Impl/DivImpl.h 2013-02-22 18:38:06.717591849 +0100
1307@@ -162,58 +162,6 @@
1308
1309
1310 template <class TS> SYS_INLINE STATIC
1311- TS SafeDivC_scale(const TS &s, const TS &v, int scale)
1312- {
1313- if(!v)
1314- return s ;
1315- else
1316- return DivC_scale(s, v, scale);
1317- }
1318-
1319- template <class TS> SYS_INLINE STATIC
1320- TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
1321- {
1322- if(!v)
1323- return d ;
1324- else
1325- return DivC_scale(s, v, scale );
1326- }
1327-
1328- template<class TS> STATIC
1329- TS SafeDivC(const TS &s, const TS &v, const TS &d )
1330- {
1331- if(!v)
1332- return d;
1333- else
1334- return s/v ;
1335- }
1336-
1337- static A32F SafeDivCR(const A32F &s, const A32F &v)
1338- {
1339- if(!v)
1340- {
1341- if(s>0) return Const::INF_32F;
1342- if(s<0) return Const::INF_NEG_32F;
1343- else return Const::IND_32F;
1344-
1345- }
1346- else
1347- return s/v ;
1348- }
1349-
1350- template<class TS> STATIC
1351- TS SafeDivCR(const TS &s, const TS &v)
1352- {
1353- if(!v)
1354- if (!s)
1355- return 0;
1356- else
1357- return FW_REF::Limits< TS >::MaxValue();
1358- else
1359- return s/v ;
1360- }
1361-
1362- template <class TS> SYS_INLINE STATIC
1363 TS DivC_scale(const TS &s, const TS &v, int scale)
1364 {
1365 return FW_REF::Limits<TS>::Sat(CBL_LIBRARY::DoubleToInt(FW_REF::Scale((float) s / v, scale)));
1366@@ -273,6 +221,58 @@
1367 return d;
1368 }
1369
1370+ template <class TS> SYS_INLINE STATIC
1371+ TS SafeDivC_scale(const TS &s, const TS &v, int scale)
1372+ {
1373+ if(!v)
1374+ return s ;
1375+ else
1376+ return DivC_scale(s, v, scale);
1377+ }
1378+
1379+ template <class TS> SYS_INLINE STATIC
1380+ TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
1381+ {
1382+ if(!v)
1383+ return d ;
1384+ else
1385+ return DivC_scale(s, v, scale );
1386+ }
1387+
1388+ template<class TS> STATIC
1389+ TS SafeDivC(const TS &s, const TS &v, const TS &d )
1390+ {
1391+ if(!v)
1392+ return d;
1393+ else
1394+ return s/v ;
1395+ }
1396+
1397+ static A32F SafeDivCR(const A32F &s, const A32F &v)
1398+ {
1399+ if(!v)
1400+ {
1401+ if(s>0) return Const::INF_32F;
1402+ if(s<0) return Const::INF_NEG_32F;
1403+ else return Const::IND_32F;
1404+
1405+ }
1406+ else
1407+ return s/v ;
1408+ }
1409+
1410+ template<class TS> STATIC
1411+ TS SafeDivCR(const TS &s, const TS &v)
1412+ {
1413+ if(!v)
1414+ if (!s)
1415+ return 0;
1416+ else
1417+ return FW_REF::Limits< TS >::MaxValue();
1418+ else
1419+ return s/v ;
1420+ }
1421+
1422 namespace DIV
1423 {
1424 template< class TS1, class TS2, class TD >
Framewave - set of popular image and signal processing routines
This page took 0.226029 seconds and 4 git commands to generate.