[cvs] / xvidcore / src / motion / sad.c Repository:
ViewVC logotype

Diff of /xvidcore/src/motion/sad.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.9, Sat Oct 19 11:41:11 2002 UTC revision 1.16, Mon Apr 12 15:49:56 2004 UTC
# Line 1  Line 1 
1  /*****************************************************************************  /*****************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - SAD calculation module (C part) -   *  - Sum Of Absolute Difference related code -
5   *   *
6   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>   *  Copyright(C) 2001-2003 Peter Ross <pross@xvid.org>
  *  Copyright(C) 2002 Pete Ross  
  *  
  *  This program is an implementation of a part of one or more MPEG-4  
  *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending  
  *  to use this software module in hardware or software products are  
  *  advised that its use may infringe existing patents or copyrights, and  
  *  any such use would be at such party's own risk.  The original  
  *  developer of this software module and his/her company, and subsequent  
  *  editors and their companies, will have no liability for use of this  
  *  software or modifications or derivatives thereof.  
7   *   *
8   *  This program is free software; you can redistribute it and/or modify   *  This program is free software; you can redistribute it and/or modify
9   *  it under the terms of the GNU General Public License as published by   *  it under the terms of the GNU General Public License as published by
# Line 29  Line 19 
19   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22     * $Id$
23     *
24   ****************************************************************************/   ****************************************************************************/
25    
26  #include "../portab.h"  #include "../portab.h"
27    #include "../global.h"
28  #include "sad.h"  #include "sad.h"
29    
30    #include <stdlib.h>
31    
32  sad16FuncPtr sad16;  sad16FuncPtr sad16;
33  sad8FuncPtr sad8;  sad8FuncPtr sad8;
34  sad16biFuncPtr sad16bi;  sad16biFuncPtr sad16bi;
35  sad8biFuncPtr sad8bi;           // not really sad16, but no difference in prototype  sad8biFuncPtr sad8bi;           /* not really sad16, but no difference in prototype */
36  dev16FuncPtr dev16;  dev16FuncPtr dev16;
37    sad16vFuncPtr sad16v;
38    sse8Func_16bitPtr sse8_16bit;
39    sse8Func_8bitPtr sse8_8bit;
40    
41  sadInitFuncPtr sadInit;  sadInitFuncPtr sadInit;
42    
 #define ABS(X) (((X)>0)?(X):-(X))  
   
 #define MRSAD16_CORRFACTOR 8  
 uint32_t  
 mrsad16_c(const uint8_t * const cur,  
                   const uint8_t * const ref,  
                   const uint32_t stride,  
                   const uint32_t best_sad)  
 {  
   
         uint32_t sad = 0;  
         int32_t mean = 0;  
         uint32_t i, j;  
         uint8_t const *ptr_cur = cur;  
         uint8_t const *ptr_ref = ref;  
   
         for (j = 0; j < 16; j++) {  
                 for (i = 0; i < 16; i++) {  
                         mean += ((int) *(ptr_cur + i) - (int) *(ptr_ref + i));  
                 }  
                 ptr_cur += stride;  
                 ptr_ref += stride;  
   
         }  
         mean /= 256;  
   
         for (j = 0; j < 16; j++) {  
   
                 ptr_cur -= stride;  
                 ptr_ref -= stride;  
   
                 for (i = 0; i < 16; i++) {  
   
                         sad += ABS(*(ptr_cur + i) - *(ptr_ref + i) - mean);  
                         if (sad >= best_sad) {  
                                 return MRSAD16_CORRFACTOR * sad;  
                         }  
                 }  
         }  
   
         return MRSAD16_CORRFACTOR * sad;  
   
 }  
   
43    
44  uint32_t  uint32_t
45  sad16_c(const uint8_t * const cur,  sad16_c(const uint8_t * const cur,
# Line 95  Line 49 
49  {  {
50    
51          uint32_t sad = 0;          uint32_t sad = 0;
52          uint32_t i, j;          uint32_t j;
53          uint8_t const *ptr_cur = cur;          uint8_t const *ptr_cur = cur;
54          uint8_t const *ptr_ref = ref;          uint8_t const *ptr_ref = ref;
55    
56          for (j = 0; j < 16; j++) {          for (j = 0; j < 16; j++) {
57                            sad += abs(ptr_cur[0] - ptr_ref[0]);
58                            sad += abs(ptr_cur[1] - ptr_ref[1]);
59                            sad += abs(ptr_cur[2] - ptr_ref[2]);
60                            sad += abs(ptr_cur[3] - ptr_ref[3]);
61                            sad += abs(ptr_cur[4] - ptr_ref[4]);
62                            sad += abs(ptr_cur[5] - ptr_ref[5]);
63                            sad += abs(ptr_cur[6] - ptr_ref[6]);
64                            sad += abs(ptr_cur[7] - ptr_ref[7]);
65                            sad += abs(ptr_cur[8] - ptr_ref[8]);
66                            sad += abs(ptr_cur[9] - ptr_ref[9]);
67                            sad += abs(ptr_cur[10] - ptr_ref[10]);
68                            sad += abs(ptr_cur[11] - ptr_ref[11]);
69                            sad += abs(ptr_cur[12] - ptr_ref[12]);
70                            sad += abs(ptr_cur[13] - ptr_ref[13]);
71                            sad += abs(ptr_cur[14] - ptr_ref[14]);
72                            sad += abs(ptr_cur[15] - ptr_ref[15]);
73    
74                  for (i = 0; i < 16; i++) {                          if (sad >= best_sad)
   
                         sad += ABS(*(ptr_cur + i) - *(ptr_ref + i));  
   
                         if (sad >= best_sad) {  
75                                  return sad;                                  return sad;
                         }  
   
   
                 }  
76    
77                  ptr_cur += stride;                  ptr_cur += stride;
78                  ptr_ref += stride;                  ptr_ref += stride;
# Line 121  Line 83 
83    
84  }  }
85    
   
   
86  uint32_t  uint32_t
87  sad16bi_c(const uint8_t * const cur,  sad16bi_c(const uint8_t * const cur,
88                    const uint8_t * const ref1,                    const uint8_t * const ref1,
# Line 140  Line 100 
100    
101                  for (i = 0; i < 16; i++) {                  for (i = 0; i < 16; i++) {
102                          int pixel = (ptr_ref1[i] + ptr_ref2[i] + 1) / 2;                          int pixel = (ptr_ref1[i] + ptr_ref2[i] + 1) / 2;
103                            sad += abs(ptr_cur[i] - pixel);
                         if (pixel < 0) {  
                                 pixel = 0;  
                         } else if (pixel > 255) {  
                                 pixel = 255;  
                         }  
   
                         sad += ABS(ptr_cur[i] - pixel);  
104                  }                  }
105    
106                  ptr_cur += stride;                  ptr_cur += stride;
# Line 177  Line 130 
130    
131                  for (i = 0; i < 8; i++) {                  for (i = 0; i < 8; i++) {
132                          int pixel = (ptr_ref1[i] + ptr_ref2[i] + 1) / 2;                          int pixel = (ptr_ref1[i] + ptr_ref2[i] + 1) / 2;
133                            sad += abs(ptr_cur[i] - pixel);
                         if (pixel < 0) {  
                                 pixel = 0;  
                         } else if (pixel > 255) {  
                                 pixel = 255;  
                         }  
   
                         sad += ABS(ptr_cur[i] - pixel);  
134                  }                  }
135    
136                  ptr_cur += stride;                  ptr_cur += stride;
# Line 205  Line 151 
151             const uint32_t stride)             const uint32_t stride)
152  {  {
153          uint32_t sad = 0;          uint32_t sad = 0;
154          uint32_t i, j;          uint32_t j;
155          uint8_t const *ptr_cur = cur;          uint8_t const *ptr_cur = cur;
156          uint8_t const *ptr_ref = ref;          uint8_t const *ptr_ref = ref;
157    
158          for (j = 0; j < 8; j++) {          for (j = 0; j < 8; j++) {
159    
160                  for (i = 0; i < 8; i++) {                  sad += abs(ptr_cur[0] - ptr_ref[0]);
161                          sad += ABS(*(ptr_cur + i) - *(ptr_ref + i));                  sad += abs(ptr_cur[1] - ptr_ref[1]);
162                  }                  sad += abs(ptr_cur[2] - ptr_ref[2]);
163                    sad += abs(ptr_cur[3] - ptr_ref[3]);
164                    sad += abs(ptr_cur[4] - ptr_ref[4]);
165                    sad += abs(ptr_cur[5] - ptr_ref[5]);
166                    sad += abs(ptr_cur[6] - ptr_ref[6]);
167                    sad += abs(ptr_cur[7] - ptr_ref[7]);
168    
169                  ptr_cur += stride;                  ptr_cur += stride;
170                  ptr_ref += stride;                  ptr_ref += stride;
# Line 224  Line 175 
175  }  }
176    
177    
   
   
178  /* average deviation from mean */  /* average deviation from mean */
179    
180  uint32_t  uint32_t
# Line 253  Line 202 
202          for (j = 0; j < 16; j++) {          for (j = 0; j < 16; j++) {
203    
204                  for (i = 0; i < 16; i++)                  for (i = 0; i < 16; i++)
205                          dev += ABS(*(ptr_cur + i) - (int32_t) mean);                          dev += abs(*(ptr_cur + i) - (int32_t) mean);
206    
207                  ptr_cur += stride;                  ptr_cur += stride;
208    
# Line 261  Line 210 
210    
211          return dev;          return dev;
212  }  }
213    
214    uint32_t sad16v_c(const uint8_t * const cur,
215                               const uint8_t * const ref,
216                               const uint32_t stride,
217                               int32_t *sad)
218    {
219            sad[0] = sad8(cur, ref, stride);
220            sad[1] = sad8(cur + 8, ref + 8, stride);
221            sad[2] = sad8(cur + 8*stride, ref + 8*stride, stride);
222            sad[3] = sad8(cur + 8*stride + 8, ref + 8*stride + 8, stride);
223    
224            return sad[0]+sad[1]+sad[2]+sad[3];
225    }
226    
227    uint32_t sad32v_c(const uint8_t * const cur,
228                               const uint8_t * const ref,
229                               const uint32_t stride,
230                               int32_t *sad)
231    {
232            sad[0] = sad16(cur, ref, stride, 256*4096);
233            sad[1] = sad16(cur + 16, ref + 16, stride, 256*4096);
234            sad[2] = sad16(cur + 16*stride, ref + 16*stride, stride, 256*4096);
235            sad[3] = sad16(cur + 16*stride + 16, ref + 16*stride + 16, stride, 256*4096);
236    
237            return sad[0]+sad[1]+sad[2]+sad[3];
238    }
239    
240    
241    
242    #define MRSAD16_CORRFACTOR 8
243    uint32_t
244    mrsad16_c(const uint8_t * const cur,
245                      const uint8_t * const ref,
246                      const uint32_t stride,
247                      const uint32_t best_sad)
248    {
249    
250            uint32_t sad = 0;
251            int32_t mean = 0;
252            uint32_t i, j;
253            uint8_t const *ptr_cur = cur;
254            uint8_t const *ptr_ref = ref;
255    
256            for (j = 0; j < 16; j++) {
257                    for (i = 0; i < 16; i++) {
258                            mean += ((int) *(ptr_cur + i) - (int) *(ptr_ref + i));
259                    }
260                    ptr_cur += stride;
261                    ptr_ref += stride;
262    
263            }
264            mean /= 256;
265    
266            for (j = 0; j < 16; j++) {
267    
268                    ptr_cur -= stride;
269                    ptr_ref -= stride;
270    
271                    for (i = 0; i < 16; i++) {
272    
273                            sad += abs(*(ptr_cur + i) - *(ptr_ref + i) - mean);
274                            if (sad >= best_sad) {
275                                    return MRSAD16_CORRFACTOR * sad;
276                            }
277                    }
278            }
279    
280            return MRSAD16_CORRFACTOR * sad;
281    }
282    
283    uint32_t
284    sse8_16bit_c(const int16_t * b1,
285                             const int16_t * b2,
286                             const uint32_t stride)
287    {
288            int i;
289            int sse = 0;
290    
291            for (i=0; i<8; i++) {
292                    sse += (b1[0] - b2[0])*(b1[0] - b2[0]);
293                    sse += (b1[1] - b2[1])*(b1[1] - b2[1]);
294                    sse += (b1[2] - b2[2])*(b1[2] - b2[2]);
295                    sse += (b1[3] - b2[3])*(b1[3] - b2[3]);
296                    sse += (b1[4] - b2[4])*(b1[4] - b2[4]);
297                    sse += (b1[5] - b2[5])*(b1[5] - b2[5]);
298                    sse += (b1[6] - b2[6])*(b1[6] - b2[6]);
299                    sse += (b1[7] - b2[7])*(b1[7] - b2[7]);
300    
301                    b1 = (const int16_t*)((int8_t*)b1+stride);
302                    b2 = (const int16_t*)((int8_t*)b2+stride);
303            }
304    
305            return(sse);
306    }
307    
308    uint32_t
309    sse8_8bit_c(const uint8_t * b1,
310                            const uint8_t * b2,
311                            const uint32_t stride)
312    {
313            int i;
314            int sse = 0;
315    
316            for (i=0; i<8; i++) {
317                    sse += (b1[0] - b2[0])*(b1[0] - b2[0]);
318                    sse += (b1[1] - b2[1])*(b1[1] - b2[1]);
319                    sse += (b1[2] - b2[2])*(b1[2] - b2[2]);
320                    sse += (b1[3] - b2[3])*(b1[3] - b2[3]);
321                    sse += (b1[4] - b2[4])*(b1[4] - b2[4]);
322                    sse += (b1[5] - b2[5])*(b1[5] - b2[5]);
323                    sse += (b1[6] - b2[6])*(b1[6] - b2[6]);
324                    sse += (b1[7] - b2[7])*(b1[7] - b2[7]);
325    
326                    b1 = b1+stride;
327                    b2 = b2+stride;
328            }
329    
330            return(sse);
331    }
Legend:
Removed from v.1.9  
changed lines
  Added in v.1.16
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4