- enhanced c++ patch to cover gcc 4.7 auto/th/framewave-1.3.1-1
authorJakub Bogusz <qboosh@pld-linux.org>
Fri, 22 Feb 2013 18:03:54 +0000 (19:03 +0100)
committerJakub Bogusz <qboosh@pld-linux.org>
Fri, 22 Feb 2013 18:03:54 +0000 (19:03 +0100)
framewave-c++.patch

index 7308442ad41b4e55f98a35db503b53582da0b1d1..76455569601e2cad118f0c57fc6ea1ff719175db 100644 (file)
        const U32 width;   
        const S32 s1Step, s2Step, s3Step,s4Step; 
        U32 threads;   
+--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter_ProcessorTemplates.h.orig      2009-07-09 11:15:30.000000000 +0200
++++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter_ProcessorTemplates.h   2013-02-22 15:24:57.545866926 +0100
+@@ -52,7 +52,7 @@
+                 while( pDstElement < pLineEnd )
+                 {
+                     // perform the pixel calculations
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
+                     pSrcElement++;
+                     pDstElement++;
+                 }
+@@ -101,9 +101,9 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
+-                    Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep );
+-                    Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep );
+                     pSrcElement += 4;
+                     pDstElement += 4;
+                 }
+@@ -151,7 +151,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
+                     pSrcElement++;
+                     pDstElement++;
+                 }
+@@ -200,9 +200,9 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
+-                    Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor );
+-                    Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor );
+                     pSrcElement += 4;
+                     pDstElement += 4;
+                 }
+@@ -250,7 +250,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement, pData->srcStep, 
+                                pDstElement, pData->dstStep, 
+                                (const Fw32s *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor, pData->divisor );
+@@ -302,15 +302,15 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement, pData->srcStep, 
+                                pDstElement, pData->dstStep, 
+                                (const Fw32s *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor, pData->divisor );
+-                    Calculate( pSrcElement+1, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement+1, pData->srcStep, 
+                                pDstElement+1, pData->dstStep, 
+                                (const Fw32s *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor, pData->divisor );
+-                    Calculate( pSrcElement+2, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor_divisor::Calculate( pSrcElement+2, pData->srcStep, 
+                                pDstElement+2, pData->dstStep, 
+                                (const Fw32s *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor, pData->divisor );
+@@ -361,7 +361,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement, pData->srcStep, 
+                                pDstElement, pData->dstStep, 
+                                (const Fw32f *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor );
+@@ -413,15 +413,15 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement, pData->srcStep, 
+                                pDstElement, pData->dstStep, 
+                                (const Fw32f *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor );
+-                    Calculate( pSrcElement+1, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement+1, pData->srcStep, 
+                                pDstElement+1, pData->dstStep, 
+                                (const Fw32f *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor );
+-                    Calculate( pSrcElement+2, pData->srcStep, 
++                    TProcessor_pSrc_sStep_pDst_dStep_roi_kernel_size_anchor::Calculate( pSrcElement+2, pData->srcStep, 
+                                pDstElement+2, pData->dstStep, 
+                                (const Fw32f *)pData->pKernel, pData->kernelSize, 
+                                pData->anchor );
+@@ -471,7 +471,7 @@
+                 DstType *pLineEnd = pDstElement + pData->dstRoiSize.width * chCount;
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+                     pSrcElement++;
+                     pDstElement++;
+                 }
+@@ -520,9 +520,9 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+-                    Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+-                    Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+1, pData->srcStep, pDstElement+1, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::Calculate( pSrcElement+2, pData->srcStep, pDstElement+2, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+                     *(pDstElement+3) = *(pSrcElement+3);
+                     pSrcElement += 4;
+                     pDstElement += 4;
+@@ -571,7 +571,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessorAllChannels_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
+                     pSrcElement += chCount;
+                     pDstElement += chCount;
+                 }
+@@ -620,7 +620,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
++                    TProcessorAllChannels_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor );
+                     pSrcElement += 4;
+                     pDstElement += 4;
+                 }
+@@ -668,7 +668,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorAllChannelsWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+                     pSrcElement += chCount;
+                     pDstElement += chCount;
+                 }
+@@ -717,7 +717,7 @@
+                 // iterate through the destination data from left to right
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
++                    TProcessorAllChannelsWithBuffer_pSrc_sStep_pDst_dStep_roi_mask_anchor::CalculateAllChannels( pSrcElement, pData->srcStep, pDstElement, pData->dstStep, pData->maskSize, pData->anchor, pData->pBufferObj );
+                     pSrcElement += 4;
+                     pDstElement += 4;
+                 }
+@@ -773,7 +773,7 @@
+                 DstType * pDstElement = pDst;
+                 for( int col = 0; col < pData->dstRoiSize.width * chCount; col++ )
+                 {
+-                    Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
++                    TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
+                     pDstElement++;
+                 }
+                 pDst = FW_REF::Offset(pDst, pData->dstStep);
+@@ -820,9 +820,9 @@
+                 DstType * pDstElement = pDst;
+                 for( int col = 0; col < pData->dstRoiSize.width * AC4; )
+                 {
+-                    Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
+-                    Calculate( borderBufferObj, col+1, pDstElement+1, pData->maskSize, pData->anchor );
+-                    Calculate( borderBufferObj, col+2, pDstElement+2, pData->maskSize, pData->anchor );
++                    TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col, pDstElement, pData->maskSize, pData->anchor );
++                    TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col+1, pDstElement+1, pData->maskSize, pData->anchor );
++                    TProcessor_WithBorder_pSrc_sStep_pDst_dStep_roi_mask_anchor_buffer::Calculate( borderBufferObj, col+2, pDstElement+2, pData->maskSize, pData->anchor );
+                     pDstElement+=4;
+                     col+=4;
+                 }
+@@ -901,7 +901,7 @@
+             {
+                 // at the beginning of each row start by calling the generic Calculate method that does
+                 // not reuse any previous calculations
+-                Calculate(  pSrc, pData->srcStep,
++                TProcessor_ZigZagRDRD::Calculate(  pSrc, pData->srcStep,
+                             pDst, pData->dstStep,
+                             pData->maskSize, 
+                             pData->anchor,
+@@ -915,7 +915,7 @@
+                 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateRight(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDRD::CalculateRight(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -963,7 +963,7 @@
+             {
+                 // at the beginning of each row start by calling the generic Calculate method that does
+                 // not reuse any previous calculations
+-                Calculate(  pSrc, pData->srcStep,
++                TProcessor_ZigZagRDRD::Calculate(  pSrc, pData->srcStep,
+                             pDst, pData->dstStep,
+                             pData->maskSize, 
+                             pData->anchor,
+@@ -977,7 +977,7 @@
+                 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateRight(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDRD::CalculateRight(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -1038,7 +1038,7 @@
+             while( pDst < pEndDst )
+             {
+                 // at the top of each column call the generic Calculate method
+-                Calculate(  pSrc, pData->srcStep,
++                TProcessor_ZigZagDRDR::Calculate(  pSrc, pData->srcStep,
+                             pDst, pData->dstStep,
+                             pData->maskSize, 
+                             pData->anchor,
+@@ -1052,7 +1052,7 @@
+                 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
+                 while( pDstElement < pColumnEnd )
+                 {
+-                    CalculateDown(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRDR::CalculateDown(  pSrcElement, pData->srcStep,
+                                     pDstElement, pData->dstStep,
+                                     pData->maskSize, 
+                                     pData->anchor,
+@@ -1100,7 +1100,7 @@
+             while( pDst < pEndDst )
+             {
+                 // at the top of each column call the generic Calculate method
+-                Calculate(  pSrc, pData->srcStep,
++                TProcessor_ZigZagDRDR::Calculate(  pSrc, pData->srcStep,
+                             pDst, pData->dstStep,
+                             pData->maskSize, 
+                             pData->anchor,
+@@ -1114,7 +1114,7 @@
+                 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
+                 while( pDstElement < pColumnEnd )
+                 {
+-                    CalculateDown(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRDR::CalculateDown(  pSrcElement, pData->srcStep,
+                                     pDstElement, pData->dstStep,
+                                     pData->maskSize, 
+                                     pData->anchor,
+@@ -1175,7 +1175,7 @@
+             DstType * pEndDst = FW_REF::Offset( pData->pDst, pData->dstRoiSize.height * pData->dstStep );
+             // start in the top left corner of the image
+-            Calculate(  pSrc, pData->srcStep,
++            TProcessor_ZigZagRDLD::Calculate(  pSrc, pData->srcStep,
+                         pDst, pData->dstStep,
+                         pData->maskSize, 
+                         pData->anchor,
+@@ -1193,7 +1193,7 @@
+                 DstType *pLineEnd = pDst + pData->dstRoiSize.width * chCount;
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateRight(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDLD::CalculateRight(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -1208,7 +1208,7 @@
+                 if( pDstElement >= pEndDst )
+                     break;
+-                CalculateDown(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagRDLD::CalculateDown(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1226,7 +1226,7 @@
+                 while( pDstElement >= pDst )
+                 {
+-                    CalculateLeft(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDLD::CalculateLeft(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -1244,7 +1244,7 @@
+                 if( pDst >= pEndDst )
+                     break;
+-                CalculateDown(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagRDLD::CalculateDown(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1282,7 +1282,7 @@
+             // calculate the pointer to the end of the destination data
+             DstType * pEndDst = FW_REF::Offset( pData->pDst, pData->dstRoiSize.height * pData->dstStep );
+-            Calculate(  pSrc, pData->srcStep,
++            TProcessor_ZigZagRDLD::Calculate(  pSrc, pData->srcStep,
+                         pDst, pData->dstStep,
+                         pData->maskSize, 
+                         pData->anchor,
+@@ -1295,7 +1295,7 @@
+                 DstType *pLineEnd = pDst + pData->dstRoiSize.width * C4;
+                 while( pDstElement < pLineEnd )
+                 {
+-                    CalculateRight(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDLD::CalculateRight(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -1308,7 +1308,7 @@
+                 if( pDstElement >= pEndDst )
+                     break;
+-                CalculateDown(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagRDLD::CalculateDown(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1320,7 +1320,7 @@
+                 while( pDstElement >= pDst )
+                 {
+-                    CalculateLeft(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagRDLD::CalculateLeft(  pSrcElement, pData->srcStep,
+                                      pDstElement, pData->dstStep,
+                                      pData->maskSize, 
+                                      pData->anchor,
+@@ -1336,7 +1336,7 @@
+                 if( pDst >= pEndDst )
+                     break;
+-                CalculateDown(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagRDLD::CalculateDown(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1391,7 +1391,7 @@
+             DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
+             // start in the top left corner
+-            Calculate(  pSrc, pData->srcStep,
++            TProcessor_ZigZagDRUR::Calculate(  pSrc, pData->srcStep,
+                         pDst, pData->dstStep,
+                         pData->maskSize, 
+                         pData->anchor,
+@@ -1407,7 +1407,7 @@
+                 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
+                 while( pDstElement < pColumnEnd )
+                 {
+-                    CalculateDown(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRUR::CalculateDown(  pSrcElement, pData->srcStep,
+                                     pDstElement, pData->dstStep,
+                                     pData->maskSize, 
+                                     pData->anchor,
+@@ -1421,7 +1421,7 @@
+                 if( pDstElement >= pEndDst2 )
+                     break;
+-                CalculateRight(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagDRUR::CalculateRight(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1436,7 +1436,7 @@
+                 while( pDstElement >= pDst )
+                 {
+-                    CalculateUp(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRUR::CalculateUp(  pSrcElement, pData->srcStep,
+                                   pDstElement, pData->dstStep,
+                                   pData->maskSize, 
+                                   pData->anchor,
+@@ -1453,7 +1453,7 @@
+                 if( pDst >= pEndDst )
+                     break;
+-                CalculateRight(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagDRUR::CalculateRight(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1493,7 +1493,7 @@
+             DstType * pEndDst2 = FW_REF::Offset( pEndDst, (pData->dstRoiSize.height-1) * pData->dstStep );
+             // start in the top left corner
+-            Calculate(  pSrc, pData->srcStep,
++            TProcessor_ZigZagDRUR::Calculate(  pSrc, pData->srcStep,
+                         pDst, pData->dstStep,
+                         pData->maskSize, 
+                         pData->anchor,
+@@ -1509,7 +1509,7 @@
+                 DstType *pColumnEnd = FW_REF::Offset( pDst, pData->dstRoiSize.height * pData->dstStep );
+                 while( pDstElement < pColumnEnd )
+                 {
+-                    CalculateDown(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRUR::CalculateDown(  pSrcElement, pData->srcStep,
+                                     pDstElement, pData->dstStep,
+                                     pData->maskSize, 
+                                     pData->anchor,
+@@ -1524,7 +1524,7 @@
+                 if( pDstElement >= pEndDst2 )
+                     break;
+-                CalculateRight(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagDRUR::CalculateRight(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+@@ -1540,7 +1540,7 @@
+                 while( pDstElement >= pDst )
+                 {
+-                    CalculateUp(  pSrcElement, pData->srcStep,
++                    TProcessor_ZigZagDRUR::CalculateUp(  pSrcElement, pData->srcStep,
+                                   pDstElement, pData->dstStep,
+                                   pData->maskSize, 
+                                   pData->anchor,
+@@ -1558,7 +1558,7 @@
+                 if( pDst >= pEndDst )
+                     break;
+-                CalculateRight(  pSrcElement, pData->srcStep,
++                TProcessor_ZigZagDRUR::CalculateRight(  pSrcElement, pData->srcStep,
+                                  pDstElement, pData->dstStep,
+                                  pData->maskSize, 
+                                  pData->anchor,
+--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterGeneral.cpp.orig    2009-07-09 11:15:34.000000000 +0200
++++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterGeneral.cpp 2013-02-22 15:44:44.933889396 +0100
+@@ -125,7 +125,7 @@
+             zero.i = _mm_setzero_si128();
+             XMM128 divisor_inv;
+-            GetDivisorInv( divisor_inv, pData->divisor );
++            FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
+             // calculate destination mask for the 4 channel with alpha scenario
+             XMM128 alphaMask;
+@@ -178,17 +178,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd += 4;
+                         ps += 4;
+@@ -201,7 +201,7 @@
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) )    // Process 1 horizontal line (16 wide)
+                 {
+-                    SSE2_Aligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
++                    FilterProcessor_superclass::SSE2_Aligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
+                 }
+                 /////////////////////////////////////////////////////////////////
+@@ -214,17 +214,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd += 4;
+                         ps += 4;
+@@ -258,7 +258,7 @@
+             zero.i = _mm_setzero_si128();
+             XMM128 divisor_inv;
+-            GetDivisorInv( divisor_inv, pData->divisor );
++            FilterProcessor_superclass::GetDivisorInv( divisor_inv, pData->divisor );
+             XMM128 alphaMask;
+             if( chCount == AC4 )
+@@ -301,7 +301,7 @@
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) )                            // Process 1 horizontal line (16 wide)
+                 {
+-                        SSE2_Unaligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
++                        FilterProcessor_superclass::SSE2_Unaligned_Impl( pData, zero, divisor_inv, kernel, ps, pd, alphaMask );
+                 }
+                 /////////////////////////////////////////////////////////////////
+@@ -314,17 +314,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                         pd += 4;
+                         ps += 4;
+@@ -425,17 +425,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd += 4;
+                         ps += 4;
+@@ -448,7 +448,7 @@
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(SrcType)) )    // Process 1 horizontal line (16 wide)
+                 {
+-                    SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
++                    FilterProcessor_NoDivision_superclass::SSE2_Aligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
+                 }
+                 /////////////////////////////////////////////////////////////////
+@@ -461,17 +461,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd += 4;
+                         ps += 4;
+@@ -546,7 +546,7 @@
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndMiddle; ps+=(16/sizeof(SrcType)), pd+=(16/sizeof(DstType)) )                            // Process 1 horizontal line (16 wide)
+                 {
+-                    SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
++                    FilterProcessor_NoDivision_superclass::SSE2_Unaligned_Impl( pData, zero, kernel, ps, pd, alphaMask );
+                 }
+                 /////////////////////////////////////////////////////////////////
+@@ -559,17 +559,17 @@
+                     case C1:
+                     case C3:
+                     case C4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd++;
+                         ps++;
+                         break;
+                     case AC4:
+-                        Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+1, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+1, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+-                        Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
++                        FilterProcessor_NoDivision_superclass::Calculate( FW_REF::Offset( ps+2, yoffset * pData->srcStep + xoffset * actualChCount * sizeof(SrcType) ),
+                                    pData->srcStep, pd+2, pData->dstStep, pKernel, pData->kernelSize, pData->anchor );
+                         pd += 4;
+                         ps += 4;
+--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterSeparable.cpp.orig  2009-07-09 11:15:34.000000000 +0200
++++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterSeparable.cpp       2013-02-22 16:02:53.624049208 +0100
+@@ -396,7 +396,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -529,7 +529,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -701,7 +701,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -767,7 +767,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -853,7 +853,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -979,7 +979,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_32f::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1045,7 +1045,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -1096,7 +1096,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1187,7 +1187,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1253,7 +1253,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -1300,7 +1300,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1386,7 +1386,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterColumnProcessor_16s_NoDivision::Calculate( (const SrcType*)(((Fw8u*)ps)+anchorOffset*pData->srcStep), pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1516,7 +1516,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -1646,7 +1646,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1709,7 +1709,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -1796,7 +1796,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -1864,7 +1864,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2034,7 +2034,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -2101,7 +2101,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2195,7 +2195,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -2262,7 +2262,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2353,7 +2353,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_5_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -2421,7 +2421,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2535,7 +2535,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_32f::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -2602,7 +2602,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2666,7 +2666,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_16s::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+@@ -2733,7 +2733,7 @@
+                 // process the unaligned "prefix" data (up to 15 bytes)
+                 /////////////////////////////////////////////////////////////////
+                 for( ; pd<pEndStart; ++pd, ++ps ) // Process 1 at a time until we hit an alignment boundary
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 for( ; pd<pEndMiddle; ps+=16, pd+=16 )                                // Process 1 horizontal line (16 wide)
+                 {
+@@ -2794,7 +2794,7 @@
+                 /////////////////////////////////////////////////////////////////
+     
+                 for( ; pd<pEnd; ++pd, ++ps )                                  // Process the remainder.
+-                    Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
++                    FilterRowProcessor_3_16s_NoDivision::Calculate( ps+anchorOffset, pData->srcStep, pd, pData->dstStep, pKernel, pData->kernelSize, pData->anchor, pData->divisor );
+                 pSrc = (const SrcType *)(((Fw8u*)pSrc) + pData->srcStep);
+                 pDst = (DstType *)(((Fw8u*)pDst) + pData->dstStep);
+--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterMedian.cpp.orig     2009-07-09 11:15:34.000000000 +0200
++++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/FilterMedian.cpp  2013-02-22 18:19:46.216893594 +0100
+@@ -98,7 +98,7 @@
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength[channel]) = *pElement;
+                     nListLength[channel]++;
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength[channel], nListLength[channel] - 1 );
++                    FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nListLength[channel], nListLength[channel] - 1 );
+                     pElement++;
+                     channel = ( channel + 1 ) % chCount;
+                 }
+@@ -130,9 +130,9 @@
+                 int channel = 0;
+                 while( pOldElement < LastElement )
+                 {
+-                    int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
++                    int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
+                     *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
++                    FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
+                     channel = ( channel + 1 ) % chCount;
+                     pOldElement++;
+@@ -167,9 +167,9 @@
+                 int channel = 0;
+                 while( pOldElement < LastElement )
+                 {
+-                    int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
++                    int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
+                     *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
++                    FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
+                     channel = ( channel + 1 ) % chCount;
+                     pOldElement++;
+@@ -201,9 +201,9 @@
+             int channel = 0;
+             while( pOldElement < LastElement )
+             {
+-                int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
++                int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
+                 channel = ( channel + 1 ) % chCount;
+                 pOldElement++;
+@@ -233,9 +233,9 @@
+             int channel = 0;
+             while( pOldElement < LastElement )
+             {
+-                int nOldIndex = BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
++                int nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * channel, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * channel + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * channel, nSortedListLength, nOldIndex );
+                 channel = ( channel + 1 ) % chCount;
+                 pOldElement++;
+@@ -281,9 +281,9 @@
+                     *(pSortedList + nSortedListLength * 1 + nListLength) = *(pElement+1);
+                     *(pSortedList + nSortedListLength * 2 + nListLength) = *(pElement+2);
+                     nListLength++;
+-                    OnePassSort( pSortedList + nSortedListLength * 0, nListLength, nListLength - 1 );
+-                    OnePassSort( pSortedList + nSortedListLength * 1, nListLength, nListLength - 1 );
+-                    OnePassSort( pSortedList + nSortedListLength * 2, nListLength, nListLength - 1 );
++                  FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nListLength, nListLength - 1 );
++                  FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nListLength, nListLength - 1 );
++                  FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nListLength, nListLength - 1 );
+                     pElement += C4;
+                 }
+                 pSrc = (SrcType*)(((Fw8u*)(pSrc)) + srcstep);
+@@ -312,19 +312,19 @@
+                 int nOldIndex;
+                 // red channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
+                 // green channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
+                 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
+-                OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
+                 // blue channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
+                 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
+-                OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
+                 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
+                 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
+@@ -352,19 +352,19 @@
+             while( pOldElement < pEnd )
+             {
+                 // red channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
+                 // green channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
+                 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
+-                OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
+                 // blue channel
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
+                 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
+-                OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
+                 pOldElement = (SrcType*)(((Fw8u*)pOldElement) + srcstep);
+                 pNewElement = (SrcType*)(((Fw8u*)pNewElement) + srcstep);
+@@ -391,17 +391,17 @@
+             int nOldIndex;
+             while( pOldElement < LastElement )
+             {
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
+                 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
+-                OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
+                 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
+-                OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
+                 pOldElement+=4;
+                 pNewElement+=4;
+@@ -428,17 +428,17 @@
+             int nOldIndex;
+             while( pOldElement < LastElement )
+             {
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 0, nSortedListLength, *pOldElement );
+                 *(pSortedList + nSortedListLength * 0 + nOldIndex) = *pNewElement;
+-                OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 0, nSortedListLength, nOldIndex );
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 1, nSortedListLength, *(pOldElement+1) );
+                 *(pSortedList + nSortedListLength * 1 + nOldIndex) = *(pNewElement+1);
+-                OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 1, nSortedListLength, nOldIndex );
+-                nOldIndex = BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
++                nOldIndex = FilterMedian::BinarySearch( pSortedList + nSortedListLength * 2, nSortedListLength, *(pOldElement+2) );
+                 *(pSortedList + nSortedListLength * 2 + nOldIndex) = *(pNewElement+2);
+-                OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
++                FilterMedian::OnePassSort( pSortedList + nSortedListLength * 2, nSortedListLength, nOldIndex );
+                 pOldElement+=4;
+                 pNewElement+=4;
+@@ -476,7 +476,7 @@
+                 for( int channel = 0; channel < chCount; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
+@@ -489,7 +489,7 @@
+                 for( int channel = 0; channel < chCount; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement += chCount;
+@@ -501,7 +501,7 @@
+                 for( int channel = 0; channel < chCount; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement += chCount;
+@@ -541,7 +541,7 @@
+                 for( int channel = 0; channel < C3; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement = (SrcType*)(((Fw8u*)(pElement)) + srcstep);
+@@ -554,7 +554,7 @@
+                 for( int channel = 0; channel < C3; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement += chCount;
+@@ -566,7 +566,7 @@
+                 for( int channel = 0; channel < C3; channel++ )
+                 {
+                     *(pSortedList + nSortedListLength * channel + nListLength) = *(pElement + channel);
+-                    OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
++                    FilterMedianCross::OnePassSort( pSortedList + nSortedListLength * channel, nListLength + 1, nListLength );
+                 }
+                 nListLength++;
+                 pElement += chCount;
+@@ -603,45 +603,45 @@
+             const SrcType * pSrcAbove = (const SrcType *)(((Fw8u*)pSrcPtr) - srcstep);
+             const SrcType * pSrcBelow = (const SrcType *)(((Fw8u*)pSrcPtr) + srcstep);
+             const SrcType * pMinPtr = pSrcPtr - chCount;
+-            minDist = Distance( pSrcPtr, pMinPtr );
++            minDist = FilterMedianColor3x3::Distance( pSrcPtr, pMinPtr );
+-            tempDist = Distance( pSrcPtr, pSrcPtr + chCount );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcPtr + chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcPtr + chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove - chCount );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove - chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove - chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove + chCount );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcAbove + chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove + chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow - chCount );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow - chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow - chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow + chCount );
++            tempDist = FilterMedianColor3x3::Distance( pSrcPtr, pSrcBelow + chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow + chCount;
+@@ -656,7 +656,7 @@
+                                                    const FwiPoint & /*anchor*/ )
+         {
+             CalcType minDist;
+-            const SrcType * pMinPtr = FindMinimum3x3( pSrcPtr, srcstep, minDist );
++            const SrcType * pMinPtr = FilterMedianColor3x3::FindMinimum3x3( pSrcPtr, srcstep, minDist );
+             *(pDst+0) = *(pMinPtr+0);
+             *(pDst+1) = *(pMinPtr+1);
+             *(pDst+2) = *(pMinPtr+2);
+@@ -674,99 +674,99 @@
+             const SrcType * pSrcBelow = (const SrcType *)(((Fw8u*)pSrcPtr) + srcstep);
+             const SrcType * pSrcBelow2 = (const SrcType *)(((Fw8u*)pSrcPtr) + 2 * srcstep);
+             
+-            const SrcType * pMinPtr = FindMinimum3x3( pSrcPtr, srcstep, minDist );
++            const SrcType * pMinPtr = FilterMedianColor5x5::FindMinimum3x3( pSrcPtr, srcstep, minDist );
+-            tempDist = Distance( pSrcPtr, pSrcPtr - chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr - chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcPtr - chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcPtr + chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcPtr + chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcPtr + chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove - chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove - chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove - chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove2 - chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove2 - chCount );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 - chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove2 - chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove2 + chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove2 + chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove2 + chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcAbove + chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcAbove + chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcAbove + chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow - chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow - chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow - chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow2 - chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow2 - chCount );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 - chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow2 - chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow2 + chCount;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow2 + chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow2 + chCount * 2;
+                 minDist = tempDist;
+             }
+-            tempDist = Distance( pSrcPtr, pSrcBelow + chCount * 2 );
++            tempDist = FilterMedianColor5x5::Distance( pSrcPtr, pSrcBelow + chCount * 2 );
+             if( tempDist < minDist )
+             {
+                 pMinPtr = pSrcBelow + chCount * 2;
+--- FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/Arithmetic/Impl/DivImpl.h.orig 2009-07-09 11:15:36.000000000 +0200
++++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/Arithmetic/Impl/DivImpl.h      2013-02-22 18:38:06.717591849 +0100
+@@ -162,58 +162,6 @@
+       template <class TS>  SYS_INLINE  STATIC
+-      TS SafeDivC_scale(const TS &s, const TS &v, int scale)
+-      {
+-              if(!v)
+-                      return s ;
+-              else
+-                      return DivC_scale(s, v, scale);
+-      }
+-
+-      template <class TS>  SYS_INLINE  STATIC
+-      TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
+-      {
+-              if(!v)
+-                      return d ;
+-              else
+-                      return DivC_scale(s, v, scale );
+-      }
+-
+-      template<class TS>  STATIC
+-      TS SafeDivC(const TS &s, const TS &v, const TS &d )
+-      {
+-              if(!v)
+-                      return d;
+-              else
+-                      return s/v ;
+-      }
+-
+-      static A32F SafeDivCR(const A32F &s, const A32F &v)
+-      {
+-              if(!v)
+-              {
+-                      if(s>0) return Const::INF_32F;
+-                      if(s<0) return Const::INF_NEG_32F;
+-                      else return Const::IND_32F;
+-
+-              }
+-              else
+-                      return s/v ;
+-      }
+-
+-      template<class TS>  STATIC
+-      TS SafeDivCR(const TS &s, const TS &v)
+-      {
+-              if(!v)
+-                      if (!s)
+-                              return 0;
+-                      else
+-                              return FW_REF::Limits< TS >::MaxValue();
+-              else
+-                      return s/v ;
+-      }
+-
+-      template <class TS>  SYS_INLINE  STATIC
+       TS DivC_scale(const TS &s, const TS &v, int scale)
+       {
+               return FW_REF::Limits<TS>::Sat(CBL_LIBRARY::DoubleToInt(FW_REF::Scale((float) s / v, scale)));
+@@ -273,6 +221,58 @@
+               return d;
+       }
++      template <class TS>  SYS_INLINE  STATIC
++      TS SafeDivC_scale(const TS &s, const TS &v, int scale)
++      {
++              if(!v)
++                      return s ;
++              else
++                      return DivC_scale(s, v, scale);
++      }
++
++      template <class TS>  SYS_INLINE  STATIC
++      TS SafeDivC_scale(const TS &s, const TS &v, const TS &d, int scale)
++      {
++              if(!v)
++                      return d ;
++              else
++                      return DivC_scale(s, v, scale );
++      }
++
++      template<class TS>  STATIC
++      TS SafeDivC(const TS &s, const TS &v, const TS &d )
++      {
++              if(!v)
++                      return d;
++              else
++                      return s/v ;
++      }
++
++      static A32F SafeDivCR(const A32F &s, const A32F &v)
++      {
++              if(!v)
++              {
++                      if(s>0) return Const::INF_32F;
++                      if(s<0) return Const::INF_NEG_32F;
++                      else return Const::IND_32F;
++
++              }
++              else
++                      return s/v ;
++      }
++
++      template<class TS>  STATIC
++      TS SafeDivCR(const TS &s, const TS &v)
++      {
++              if(!v)
++                      if (!s)
++                              return 0;
++                      else
++                              return FW_REF::Limits< TS >::MaxValue();
++              else
++                      return s/v ;
++      }
++
+       namespace DIV
+       {
+               template< class TS1, class TS2, class TD >
This page took 0.132333 seconds and 4 git commands to generate.