- - rebuild with boost 1.55.0
[packages/framewave.git] / framewave-c++.patch
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 >
This page took 0.421758 seconds and 3 git commands to generate.