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
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
18 - mutable FE &fe; // Algorithm instance
19 + FE &fe; // Algorithm instance
21 const S32 s1Step, s2Step, s3Step,s4Step;
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
26 while( pDstElement < pLineEnd )
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 );
35 // iterate through the destination data from left to right
36 while( pDstElement < pLineEnd )
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 );
48 // iterate through the destination data from left to right
49 while( pDstElement < pLineEnd )
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 );
57 // iterate through the destination data from left to right
58 while( pDstElement < pLineEnd )
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 );
70 // iterate through the destination data from left to right
71 while( pDstElement < pLineEnd )
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 );
79 // iterate through the destination data from left to right
80 while( pDstElement < pLineEnd )
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 );
98 // iterate through the destination data from left to right
99 while( pDstElement < pLineEnd )
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,
106 @@ -413,15 +413,15 @@
107 // iterate through the destination data from left to right
108 while( pDstElement < pLineEnd )
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,
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,
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,
126 DstType *pLineEnd = pDstElement + pData->dstRoiSize.width * chCount;
127 while( pDstElement < pLineEnd )
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 );
135 // iterate through the destination data from left to right
136 while( pDstElement < pLineEnd )
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);
148 // iterate through the destination data from left to right
149 while( pDstElement < pLineEnd )
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;
157 // iterate through the destination data from left to right
158 while( pDstElement < pLineEnd )
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 );
166 // iterate through the destination data from left to right
167 while( pDstElement < pLineEnd )
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;
175 // iterate through the destination data from left to right
176 while( pDstElement < pLineEnd )
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 );
184 DstType * pDstElement = pDst;
185 for( int col = 0; col < pData->dstRoiSize.width * chCount; col++ )
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 );
191 pDst = FW_REF::Offset(pDst, pData->dstStep);
193 DstType * pDstElement = pDst;
194 for( int col = 0; col < pData->dstRoiSize.width * AC4; )
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 );
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,
215 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
216 while( pDstElement < pLineEnd )
218 - CalculateRight( pSrcElement, pData->srcStep,
219 + TProcessor_ZigZagRDRD::CalculateRight( pSrcElement, pData->srcStep,
220 pDstElement, pData->dstStep,
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,
233 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
234 while( pDstElement < pLineEnd )
236 - CalculateRight( pSrcElement, pData->srcStep,
237 + TProcessor_ZigZagRDRD::CalculateRight( pSrcElement, pData->srcStep,
238 pDstElement, pData->dstStep,
241 @@ -1038,7 +1038,7 @@
242 while( pDst < pEndDst )
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,
250 @@ -1052,7 +1052,7 @@
251 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
252 while( pDstElement < pColumnEnd )
254 - CalculateDown( pSrcElement, pData->srcStep,
255 + TProcessor_ZigZagDRDR::CalculateDown( pSrcElement, pData->srcStep,
256 pDstElement, pData->dstStep,
259 @@ -1100,7 +1100,7 @@
260 while( pDst < pEndDst )
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,
268 @@ -1114,7 +1114,7 @@
269 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
270 while( pDstElement < pColumnEnd )
272 - CalculateDown( pSrcElement, pData->srcStep,
273 + TProcessor_ZigZagDRDR::CalculateDown( pSrcElement, pData->srcStep,
274 pDstElement, pData->dstStep,
277 @@ -1175,7 +1175,7 @@
278 DstType * pEndDst = FW_REF::Offset( pData->pDst, pData->dstRoiSize.height * pData->dstStep );
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,
286 @@ -1193,7 +1193,7 @@
287 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
288 while( pDstElement < pLineEnd )
290 - CalculateRight( pSrcElement, pData->srcStep,
291 + TProcessor_ZigZagRDLD::CalculateRight( pSrcElement, pData->srcStep,
292 pDstElement, pData->dstStep,
295 @@ -1208,7 +1208,7 @@
296 if( pDstElement >= pEndDst )
299 - CalculateDown( pSrcElement, pData->srcStep,
300 + TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
301 pDstElement, pData->dstStep,
304 @@ -1226,7 +1226,7 @@
306 while( pDstElement >= pDst )
308 - CalculateLeft( pSrcElement, pData->srcStep,
309 + TProcessor_ZigZagRDLD::CalculateLeft( pSrcElement, pData->srcStep,
310 pDstElement, pData->dstStep,
313 @@ -1244,7 +1244,7 @@
314 if( pDst >= pEndDst )
317 - CalculateDown( pSrcElement, pData->srcStep,
318 + TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
319 pDstElement, pData->dstStep,
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 );
326 - Calculate( pSrc, pData->srcStep,
327 + TProcessor_ZigZagRDLD::Calculate( pSrc, pData->srcStep,
328 pDst, pData->dstStep,
331 @@ -1295,7 +1295,7 @@
332 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
333 while( pDstElement < pLineEnd )
335 - CalculateRight( pSrcElement, pData->srcStep,
336 + TProcessor_ZigZagRDLD::CalculateRight( pSrcElement, pData->srcStep,
337 pDstElement, pData->dstStep,
340 @@ -1308,7 +1308,7 @@
341 if( pDstElement >= pEndDst )
344 - CalculateDown( pSrcElement, pData->srcStep,
345 + TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
346 pDstElement, pData->dstStep,
349 @@ -1320,7 +1320,7 @@
351 while( pDstElement >= pDst )
353 - CalculateLeft( pSrcElement, pData->srcStep,
354 + TProcessor_ZigZagRDLD::CalculateLeft( pSrcElement, pData->srcStep,
355 pDstElement, pData->dstStep,
358 @@ -1336,7 +1336,7 @@
359 if( pDst >= pEndDst )
362 - CalculateDown( pSrcElement, pData->srcStep,
363 + TProcessor_ZigZagRDLD::CalculateDown( pSrcElement, pData->srcStep,
364 pDstElement, pData->dstStep,
367 @@ -1391,7 +1391,7 @@
368 DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
370 // start in the top left corner
371 - Calculate( pSrc, pData->srcStep,
372 + TProcessor_ZigZagDRUR::Calculate( pSrc, pData->srcStep,
373 pDst, pData->dstStep,
376 @@ -1407,7 +1407,7 @@
377 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
378 while( pDstElement < pColumnEnd )
380 - CalculateDown( pSrcElement, pData->srcStep,
381 + TProcessor_ZigZagDRUR::CalculateDown( pSrcElement, pData->srcStep,
382 pDstElement, pData->dstStep,
385 @@ -1421,7 +1421,7 @@
386 if( pDstElement >= pEndDst2 )
389 - CalculateRight( pSrcElement, pData->srcStep,
390 + TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
391 pDstElement, pData->dstStep,
394 @@ -1436,7 +1436,7 @@
396 while( pDstElement >= pDst )
398 - CalculateUp( pSrcElement, pData->srcStep,
399 + TProcessor_ZigZagDRUR::CalculateUp( pSrcElement, pData->srcStep,
400 pDstElement, pData->dstStep,
403 @@ -1453,7 +1453,7 @@
404 if( pDst >= pEndDst )
407 - CalculateRight( pSrcElement, pData->srcStep,
408 + TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
409 pDstElement, pData->dstStep,
412 @@ -1493,7 +1493,7 @@
413 DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
415 // start in the top left corner
416 - Calculate( pSrc, pData->srcStep,
417 + TProcessor_ZigZagDRUR::Calculate( pSrc, pData->srcStep,
418 pDst, pData->dstStep,
421 @@ -1509,7 +1509,7 @@
422 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
423 while( pDstElement < pColumnEnd )
425 - CalculateDown( pSrcElement, pData->srcStep,
426 + TProcessor_ZigZagDRUR::CalculateDown( pSrcElement, pData->srcStep,
427 pDstElement, pData->dstStep,
430 @@ -1524,7 +1524,7 @@
431 if( pDstElement >= pEndDst2 )
434 - CalculateRight( pSrcElement, pData->srcStep,
435 + TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
436 pDstElement, pData->dstStep,
439 @@ -1540,7 +1540,7 @@
441 while( pDstElement >= pDst )
443 - CalculateUp( pSrcElement, pData->srcStep,
444 + TProcessor_ZigZagDRUR::CalculateUp( pSrcElement, pData->srcStep,
445 pDstElement, pData->dstStep,
448 @@ -1558,7 +1558,7 @@
449 if( pDst >= pEndDst )
452 - CalculateRight( pSrcElement, pData->srcStep,
453 + TProcessor_ZigZagDRUR::CalculateRight( pSrcElement, pData->srcStep,
454 pDstElement, pData->dstStep,
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
460 zero.i = _mm_setzero_si128();
463 - GetDivisorInv( divisor_inv, pData->divisor );
464 + FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
466 // calculate destination mask for the 4 channel with alpha scenario
468 @@ -178,17 +178,17 @@
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 );
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 );
491 /////////////////////////////////////////////////////////////////
492 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) ) // Process 1 horizontal line (16 wide)
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 );
498 /////////////////////////////////////////////////////////////////
499 @@ -214,17 +214,17 @@
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 );
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 );
522 zero.i = _mm_setzero_si128();
525 - GetDivisorInv( divisor_inv, pData->divisor );
526 + FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
531 /////////////////////////////////////////////////////////////////
532 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) ) // Process 1 horizontal line (16 wide)
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 );
538 /////////////////////////////////////////////////////////////////
539 @@ -314,17 +314,17 @@
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 );
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 );
561 @@ -425,17 +425,17 @@
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 );
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 );
584 /////////////////////////////////////////////////////////////////
585 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) ) // Process 1 horizontal line (16 wide)
587 - SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
588 + FilterProcessor_NoDivision_superclass::SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
591 /////////////////////////////////////////////////////////////////
592 @@ -461,17 +461,17 @@
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 );
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 );
615 /////////////////////////////////////////////////////////////////
616 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) ) // Process 1 horizontal line (16 wide)
618 - SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
619 + FilterProcessor_NoDivision_superclass::SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
622 /////////////////////////////////////////////////////////////////
623 @@ -559,17 +559,17 @@
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 );
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 );
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
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 );
654 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
657 /////////////////////////////////////////////////////////////////
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 );
663 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
664 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
666 /////////////////////////////////////////////////////////////////
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 );
672 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
673 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
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 );
681 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
684 /////////////////////////////////////////////////////////////////
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 );
690 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
691 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
693 /////////////////////////////////////////////////////////////////
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 );
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 );
708 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
710 @@ -1096,7 +1096,7 @@
711 /////////////////////////////////////////////////////////////////
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 );
717 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
718 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
719 @@ -1187,7 +1187,7 @@
720 /////////////////////////////////////////////////////////////////
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 );
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 );
735 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
737 @@ -1300,7 +1300,7 @@
738 /////////////////////////////////////////////////////////////////
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 );
744 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
745 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
746 @@ -1386,7 +1386,7 @@
747 /////////////////////////////////////////////////////////////////
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 );
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 );
762 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
764 @@ -1646,7 +1646,7 @@
765 /////////////////////////////////////////////////////////////////
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 );
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 );
780 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
782 @@ -1796,7 +1796,7 @@
783 /////////////////////////////////////////////////////////////////
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 );
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 );
798 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
800 @@ -2034,7 +2034,7 @@
801 /////////////////////////////////////////////////////////////////
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 );
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 );
816 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
818 @@ -2195,7 +2195,7 @@
819 /////////////////////////////////////////////////////////////////
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 );
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 );
834 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
836 @@ -2353,7 +2353,7 @@
837 /////////////////////////////////////////////////////////////////
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 );
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 );
852 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
854 @@ -2535,7 +2535,7 @@
855 /////////////////////////////////////////////////////////////////
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 );
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 );
870 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
872 @@ -2666,7 +2666,7 @@
873 /////////////////////////////////////////////////////////////////
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 );
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 );
888 for( ; pd<pEndMiddle; ps+=16, pd+=16 ) // Process 1 horizontal line (16 wide)
890 @@ -2794,7 +2794,7 @@
891 /////////////////////////////////////////////////////////////////
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 );
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
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 );
908 channel = ( channel + 1 ) % chCount;
912 while( pOldElement < LastElement )
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 );
920 channel = ( channel + 1 ) % chCount;
924 while( pOldElement < LastElement )
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 );
932 channel = ( channel + 1 ) % chCount;
936 while( pOldElement < LastElement )
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 );
944 channel = ( channel + 1 ) % chCount;
948 while( pOldElement < LastElement )
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 );
956 channel = ( channel + 1 ) % chCount;
959 *(pSortedList + nSortedListLength * 1 + nListLength) = *(pElement+1);
960 *(pSortedList + nSortedListLength * 2 + nListLength) = *(pElement+2);
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 );
970 pSrc = (SrcType*)(((Fw8u*)(pSrc)) + srcstep);
971 @@ -312,19 +312,19 @@
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 );
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 );
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 );
995 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
996 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
997 @@ -352,19 +352,19 @@
998 while( pOldElement < pEnd )
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 );
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 );
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 );
1021 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
1022 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
1023 @@ -391,17 +391,17 @@
1025 while( pOldElement < LastElement )
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 );
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 );
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 );
1047 @@ -428,17 +428,17 @@
1049 while( pOldElement < LastElement )
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 );
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 );
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 );
1072 for( int channel = 0; channel < chCount; channel++ )
1074 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1075 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1076 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1079 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
1081 for( int channel = 0; channel < chCount; channel++ )
1083 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1084 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1085 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1088 pElement += chCount;
1090 for( int channel = 0; channel < chCount; channel++ )
1092 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1093 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1094 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1097 pElement += chCount;
1099 for( int channel = 0; channel < C3; channel++ )
1101 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1102 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1103 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1106 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
1108 for( int channel = 0; channel < C3; channel++ )
1110 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1111 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1112 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1115 pElement += chCount;
1117 for( int channel = 0; channel < C3; channel++ )
1119 *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
1120 - OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
1121 + FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, 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 );
1132 - tempDist = Distance( pSrcPtr, pSrcPtr + chCount );
1133 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcPtr + chCount );
1134 if( tempDist < minDist )
1136 pMinPtr = pSrcPtr + chCount;
1139 - tempDist = Distance( pSrcPtr, pSrcAbove - chCount );
1140 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove - chCount );
1141 if( tempDist < minDist )
1143 pMinPtr = pSrcAbove - chCount;
1146 - tempDist = Distance( pSrcPtr, pSrcAbove );
1147 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove );
1148 if( tempDist < minDist )
1150 pMinPtr = pSrcAbove;
1153 - tempDist = Distance( pSrcPtr, pSrcAbove + chCount );
1154 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove + chCount );
1155 if( tempDist < minDist )
1157 pMinPtr = pSrcAbove + chCount;
1160 - tempDist = Distance( pSrcPtr, pSrcBelow - chCount );
1161 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow - chCount );
1162 if( tempDist < minDist )
1164 pMinPtr = pSrcBelow - chCount;
1167 - tempDist = Distance( pSrcPtr, pSrcBelow );
1168 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow );
1169 if( tempDist < minDist )
1171 pMinPtr = pSrcBelow;
1174 - tempDist = Distance( pSrcPtr, pSrcBelow + chCount );
1175 + tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow + chCount );
1176 if( tempDist < minDist )
1178 pMinPtr = pSrcBelow + chCount;
1180 const FwiPoint & /*anchor*/ )
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);
1192 - const SrcType * pMinPtr = FindMinimum3x3( pSrcPtr, srcstep, minDist );
1193 + const SrcType * pMinPtr = FilterMedianColor5x5::FindMinimum3x3( pSrcPtr, srcstep, minDist );
1195 - tempDist = Distance( pSrcPtr, pSrcPtr - chCount * 2 );
1196 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr - chCount * 2 );
1197 if( tempDist < minDist )
1199 pMinPtr = pSrcPtr - chCount * 2;
1202 - tempDist = Distance( pSrcPtr, pSrcPtr + chCount * 2 );
1203 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr + chCount * 2 );
1204 if( tempDist < minDist )
1206 pMinPtr = pSrcPtr + chCount * 2;
1209 - tempDist = Distance( pSrcPtr, pSrcAbove - chCount * 2 );
1210 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove - chCount * 2 );
1211 if( tempDist < minDist )
1213 pMinPtr = pSrcAbove - chCount * 2;
1216 - tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
1217 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
1218 if( tempDist < minDist )
1220 pMinPtr = pSrcAbove2 - chCount * 2;
1223 - tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount );
1224 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount );
1225 if( tempDist < minDist )
1227 pMinPtr = pSrcAbove2 - chCount;
1230 - tempDist = Distance( pSrcPtr, pSrcAbove2 );
1231 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 );
1232 if( tempDist < minDist )
1234 pMinPtr = pSrcAbove2;
1237 - tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount );
1238 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount );
1239 if( tempDist < minDist )
1241 pMinPtr = pSrcAbove2 + chCount;
1244 - tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
1245 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
1246 if( tempDist < minDist )
1248 pMinPtr = pSrcAbove2 + chCount * 2;
1251 - tempDist = Distance( pSrcPtr, pSrcAbove + chCount * 2 );
1252 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove + chCount * 2 );
1253 if( tempDist < minDist )
1255 pMinPtr = pSrcAbove + chCount * 2;
1258 - tempDist = Distance( pSrcPtr, pSrcBelow - chCount * 2 );
1259 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow - chCount * 2 );
1260 if( tempDist < minDist )
1262 pMinPtr = pSrcBelow - chCount * 2;
1265 - tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
1266 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
1267 if( tempDist < minDist )
1269 pMinPtr = pSrcBelow2 - chCount * 2;
1272 - tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount );
1273 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount );
1274 if( tempDist < minDist )
1276 pMinPtr = pSrcBelow2 - chCount;
1279 - tempDist = Distance( pSrcPtr, pSrcBelow2 );
1280 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 );
1281 if( tempDist < minDist )
1283 pMinPtr = pSrcBelow2;
1286 - tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount );
1287 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount );
1288 if( tempDist < minDist )
1290 pMinPtr = pSrcBelow2 + chCount;
1293 - tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
1294 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
1295 if( tempDist < minDist )
1297 pMinPtr = pSrcBelow2 + chCount * 2;
1300 - tempDist = Distance( pSrcPtr, pSrcBelow + chCount * 2 );
1301 + tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow + chCount * 2 );
1302 if( tempDist < minDist )
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 @@
1310 template <class TS> SYS_INLINE STATIC
1311 - TS SafeDivC_scale(const TS &s, const TS &v, int scale)
1316 - return DivC_scale(s, v, scale);
1319 - template <class TS> SYS_INLINE STATIC
1320 - TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
1325 - return DivC_scale(s, v, scale );
1328 - template<class TS> STATIC
1329 - TS SafeDivC(const TS &s, const TS &v, const TS &d )
1337 - static A32F SafeDivCR(const A32F &s, const A32F &v)
1341 - if(s>0) return Const::INF_32F;
1342 - if(s<0) return Const::INF_NEG_32F;
1343 - else return Const::IND_32F;
1350 - template<class TS> STATIC
1351 - TS SafeDivCR(const TS &s, const TS &v)
1357 - return FW_REF::Limits< TS >::MaxValue();
1362 - template <class TS> SYS_INLINE STATIC
1363 TS DivC_scale(const TS &s, const TS &v, int scale)
1365 return FW_REF::Limits<TS>::Sat(CBL_LIBRARY::DoubleToInt(FW_REF::Scale((float) s / v, scale)));
1366 @@ -273,6 +221,58 @@
1370 + template <class TS> SYS_INLINE STATIC
1371 + TS SafeDivC_scale(const TS &s, const TS &v, int scale)
1376 + return DivC_scale(s, v, scale);
1379 + template <class TS> SYS_INLINE STATIC
1380 + TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
1385 + return DivC_scale(s, v, scale );
1388 + template<class TS> STATIC
1389 + TS SafeDivC(const TS &s, const TS &v, const TS &d )
1397 + static A32F SafeDivCR(const A32F &s, const A32F &v)
1401 + if(s>0) return Const::INF_32F;
1402 + if(s<0) return Const::INF_NEG_32F;
1403 + else return Const::IND_32F;
1410 + template<class TS> STATIC
1411 + TS SafeDivCR(const TS &s, const TS &v)
1417 + return FW_REF::Limits< TS >::MaxValue();
1424 template< class TS1, class TS2, class TD >