framewave-c++.patch

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