]>
Commit | Line | Data |
---|---|---|
7a3dd3af JB |
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; | |
5663eee6 JB |
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 > | |
25ef52de JB |
1425 | --- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/Mirror.cpp.orig 2009-07-09 11:15:34.000000000 +0200 |
1426 | +++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/src/Mirror.cpp 2015-12-24 13:41:28.316508869 +0100 | |
1427 | @@ -1130,9 +1130,7 @@ | |
1428 | TS *ptDstRow ; | |
1429 | bool isAligned ; | |
1430 | ||
1431 | - switch((chSrc <= 4)) | |
1432 | - { | |
1433 | - case(true): | |
1434 | + if(chSrc <= 4) { | |
1435 | for (y=0; y<roiSize.height; y++) { | |
1436 | ptSrcRow = &pSrc[y*srcStep] ; | |
1437 | ptDstRow = &pDst[(roiSize.height-y-1)*dstStep]; | |
1438 | @@ -1143,8 +1141,7 @@ | |
1439 | else | |
1440 | Memcpy_SSE2<false>(ptDstRow, ptSrcRow, numBytes); | |
1441 | } | |
1442 | - break; | |
1443 | - default: //AC4 | |
1444 | + } else { //AC4 | |
1445 | __m128i mask; | |
1446 | Get_AC4_mask<TS>(mask); | |
1447 | for (y=0; y<roiSize.height; y++){ | |
1448 | @@ -1157,7 +1154,6 @@ | |
1449 | else | |
1450 | Memcpy_AC4_SSE2<TS, false>(ptDstRow, ptSrcRow, numBytes, mask); | |
1451 | } | |
1452 | - break; | |
1453 | } | |
1454 | return fwStsNoErr; | |
1455 | } | |
2f0fee9c JB |
1456 | --- FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fwdev.h.orig 2009-07-09 11:15:40.000000000 +0200 |
1457 | +++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/common/include/fwdev.h 2017-04-15 12:01:46.003904127 +0200 | |
1458 | @@ -36,7 +36,7 @@ This software is subject to the Apache v | |
1459 | //======================================= | |
1460 | // Static Assert | |
1461 | //======================================= | |
1462 | -#define STATIC_ASSERT( arg ) static_assert<arg>() | |
1463 | +#define STATIC_ASSERT( arg ) fw_static_assert<arg>() | |
1464 | ||
1465 | ||
1466 | //======================================= | |
1467 | @@ -83,12 +83,12 @@ namespace OPT_LEVEL | |
1468 | { | |
1469 | ||
1470 | template<bool b> | |
1471 | - struct static_assert {}; | |
1472 | + struct fw_static_assert {}; | |
1473 | template<> | |
1474 | - struct static_assert<false> | |
1475 | + struct fw_static_assert<false> | |
1476 | { | |
1477 | private: | |
1478 | - static_assert(); | |
1479 | + fw_static_assert(); | |
1480 | }; | |
1481 | } // namespace OPT_LEVEL | |
1482 | ||
1483 | --- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter.h.orig 2009-07-09 11:15:30.000000000 +0200 | |
1484 | +++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwImage/include/Filter.h 2017-04-15 12:56:42.006179581 +0200 | |
1485 | @@ -1119,22 +1119,22 @@ namespace FilterCommon | |
1486 | typename _DstType_, | |
1487 | typename _CalcType_, | |
1488 | template< CH, | |
1489 | - typename _SrcType_, | |
1490 | - typename _DstType_, | |
1491 | - typename _CalcType_, | |
1492 | - template< CH _chCount_, | |
1493 | - typename _SrcType_ > class _BorderType_ | |
1494 | + typename, | |
1495 | + typename, | |
1496 | + typename, | |
1497 | + template< CH, | |
1498 | + typename > class _BorderType_ | |
1499 | > class _Operator_, | |
1500 | template< typename, typename > class _DataType_, | |
1501 | - template< CH _chCount_, | |
1502 | - typename _SrcType_ > class _BorderType_ | |
1503 | + template< CH, | |
1504 | + typename> class _BorderType_ | |
1505 | > class Processor, | |
1506 | template< CH _chCount_, | |
1507 | typename _SrcType_, | |
1508 | typename _DstType_, | |
1509 | typename _CalcType_, | |
1510 | - template< CH _chCount_, | |
1511 | - typename _SrcType_ > class _BorderType_ | |
1512 | + template< CH, | |
1513 | + typename > class _BorderType_ | |
1514 | > class Operator, | |
1515 | template< typename _SrcType_, | |
1516 | typename _DstType_ | |
1517 | --- FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwVideo/src/H264-Transform.cpp.orig 2009-07-09 11:15:35.000000000 +0200 | |
1518 | +++ FRAMEWAVE_1.3.1_SRC/Framewave/domain/fwVideo/src/H264-Transform.cpp 2017-04-15 13:45:20.673252419 +0200 | |
1519 | @@ -114,7 +114,7 @@ FwStatus PREFIX_OPT(OPT_PREFIX, fwiTrans | |
1520 | count = 0; | |
1521 | for (coeff_ctr=0;coeff_ctr<4;coeff_ctr++) | |
1522 | { | |
1523 | - level =(abs(pTBlock[coeff_ctr]) * quant_coef[qp_rem][0][0] + 2*qp_const) >> (q_bits+1); | |
1524 | + level =(absm(pTBlock[coeff_ctr]) * quant_coef[qp_rem][0][0] + 2*qp_const) >> (q_bits+1); | |
1525 | pSrcDst[coeff_ctr]=(Fw16s) sign(level,pTBlock[coeff_ctr]); | |
1526 | if(pSrcDst[coeff_ctr] > MAX_CAVLC_LEVEL_VALUE) return fwStsScaleRangeErr; | |
1527 | } | |
1528 | @@ -189,7 +189,7 @@ FwStatus PREFIX_OPT(OPT_PREFIX, fwiTrans | |
1529 | for (coeff_ctr=0;coeff_ctr<16;coeff_ctr++) | |
1530 | { | |
1531 | i=pScanMatrix[coeff_ctr]; | |
1532 | - level= (abs(pTBlock[i]) * quant_coef[qp_rem][0][0] + 2*qp_const)>>(q_bits+1); | |
1533 | + level= (absm(pTBlock[i]) * quant_coef[qp_rem][0][0] + 2*qp_const)>>(q_bits+1); | |
1534 | pSrcDst[i]=(Fw16s)sign(level,pTBlock[i]); | |
1535 | if(pSrcDst[i] > MAX_CAVLC_LEVEL_VALUE) return fwStsScaleRangeErr; | |
1536 | } | |
1537 | @@ -267,7 +267,7 @@ FwStatus PREFIX_OPT(OPT_PREFIX, fwiTrans | |
1538 | { | |
1539 | i=pScanMatrix[coeff_ctr]; | |
1540 | ||
1541 | - level= ( abs( pSrcDst[i]) * quant_coef[qp_rem][i/4][i%4] + qp_const) >> q_bits; | |
1542 | + level= ( absm( pSrcDst[i]) * quant_coef[qp_rem][i/4][i%4] + qp_const) >> q_bits; | |
1543 | pSrcDst[i]=(Fw16s)sign(level*dequant_coef[qp_rem][i/4][i%4]<<qp_per,pSrcDst[i]); | |
1544 | if(pSrcDst[i] > MAX_CAVLC_LEVEL_VALUE) return fwStsScaleRangeErr; | |
1545 | } | |
1546 | --- FRAMEWAVE_1.3.1_SRC/Framewave/sdk/SSEPlus/include/SSEPlus_base.h.orig 2009-07-09 11:15:29.000000000 +0200 | |
1547 | +++ FRAMEWAVE_1.3.1_SRC/Framewave/sdk/SSEPlus/include/SSEPlus_base.h 2017-04-15 12:18:16.139325970 +0200 | |
1548 | @@ -86,7 +86,7 @@ const static double SSP_F64_ALLOWANCE = | |
1549 | //--------------------------------------- | |
1550 | #define STRING2(x) #x | |
1551 | #define STRING(x) STRING2(x) | |
1552 | -#define WARN( ) __FILE__"("STRING(__LINE__)") : NOTE " | |
1553 | +#define WARN( ) __FILE__ "(" STRING(__LINE__) ") : NOTE " | |
1554 | ||
1555 | //#define _SSP_SHUFFLE(w,x,y,z) (((w)<<3) | ((x)<<2) | ((y)<<1) | (z)) | |
1556 |