[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.7.2.2, Wed Dec 11 10:32:29 2002 UTC revision 1.11, Sun Nov 17 00:32:06 2002 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      sum of absolute difference   *  - SAD calculation module (C part) -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7   *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *               2002 Peter Ross <pross@xvid.org>
  *      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.  
8   *   *
9   *      This program is free software; you can redistribute it and/or modify   *  This file is part of XviD, a free MPEG-4 video encoder/decoder
10   *      it under the terms of the GNU General Public License as published by   *
11     *  XviD is free software; you can redistribute it and/or modify it
12     *  under the terms of the GNU General Public License as published by
13   *      the Free Software Foundation; either version 2 of the License, or   *      the Free Software Foundation; either version 2 of the License, or
14   *      (at your option) any later version.   *      (at your option) any later version.
15   *   *
# Line 24  Line 20 
20   *   *
21   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
22   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
23   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
24   *   *
25   *************************************************************************/   *  Under section 8 of the GNU General Public License, the copyright
26     *  holders of XVID explicitly forbid distribution in the following
27  /**************************************************************************   *  countries:
28   *   *
29   *      History:   *    - Japan
30     *    - United States of America
31   *   *
32   *      14.02.2002      added sad16bi_c()   *  Linking XviD statically or dynamically with other modules is making a
33   *      10.11.2001      initial version; (c)2001 peter ross <pross@cs.rmit.edu.au>   *  combined work based on XviD.  Thus, the terms and conditions of the
34     *  GNU General Public License cover the whole combination.
35   *   *
36   *************************************************************************/   *  As a special exception, the copyright holders of XviD give you
37     *  permission to link XviD with independent modules that communicate with
38     *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
39     *  license terms of these independent modules, and to copy and distribute
40     *  the resulting combined work under terms of your choice, provided that
41     *  every copy of the combined work is accompanied by a complete copy of
42     *  the source code of XviD (the version of XviD used to produce the
43     *  combined work), being distributed under the terms of the GNU General
44     *  Public License plus this exception.  An independent module is a module
45     *  which is not derived from or based on XviD.
46     *
47     *  Note that people who make modified versions of XviD are not obligated
48     *  to grant this special exception for their modified versions; it is
49     *  their choice whether to do so.  The GNU General Public License gives
50     *  permission to release a modified version without this exception; this
51     *  exception also makes it possible to release a modified version which
52     *  carries forward this exception.
53     *
54     * $Id$
55     *
56     ****************************************************************************/
57    
58  #include "../portab.h"  #include "../portab.h"
59  #include "sad.h"  #include "sad.h"
# Line 46  Line 63 
63  sad16biFuncPtr sad16bi;  sad16biFuncPtr sad16bi;
64  sad8biFuncPtr sad8bi;           // not really sad16, but no difference in prototype  sad8biFuncPtr sad8bi;           // not really sad16, but no difference in prototype
65  dev16FuncPtr dev16;  dev16FuncPtr dev16;
 sad16vFuncPtr sad16v;  
66    
67  sadInitFuncPtr sadInit;  sadInitFuncPtr sadInit;
68    
69  #define ABS(X) (((X)>0)?(X):-(X))  #define ABS(X) (((X)>0)?(X):-(X))
70    
71    #define MRSAD16_CORRFACTOR 8
72    uint32_t
73    mrsad16_c(const uint8_t * const cur,
74                      const uint8_t * const ref,
75                      const uint32_t stride,
76                      const uint32_t best_sad)
77    {
78    
79            uint32_t sad = 0;
80            int32_t mean = 0;
81            uint32_t i, j;
82            uint8_t const *ptr_cur = cur;
83            uint8_t const *ptr_ref = ref;
84    
85            for (j = 0; j < 16; j++) {
86                    for (i = 0; i < 16; i++) {
87                            mean += ((int) *(ptr_cur + i) - (int) *(ptr_ref + i));
88                    }
89                    ptr_cur += stride;
90                    ptr_ref += stride;
91    
92            }
93            mean /= 256;
94    
95            for (j = 0; j < 16; j++) {
96    
97                    ptr_cur -= stride;
98                    ptr_ref -= stride;
99    
100                    for (i = 0; i < 16; i++) {
101    
102                            sad += ABS(*(ptr_cur + i) - *(ptr_ref + i) - mean);
103                            if (sad >= best_sad) {
104                                    return MRSAD16_CORRFACTOR * sad;
105                            }
106                    }
107            }
108    
109            return MRSAD16_CORRFACTOR * sad;
110    
111    }
112    
113    
114  uint32_t  uint32_t
115  sad16_c(const uint8_t * const cur,  sad16_c(const uint8_t * const cur,
116                  const uint8_t * const ref,                  const uint8_t * const ref,
# Line 60  Line 119 
119  {  {
120    
121          uint32_t sad = 0;          uint32_t sad = 0;
122          uint32_t j;          uint32_t i, j;
123          uint8_t const *ptr_cur = cur;          uint8_t const *ptr_cur = cur;
124          uint8_t const *ptr_ref = ref;          uint8_t const *ptr_ref = ref;
125    
126          for (j = 0; j < 16; j++) {          for (j = 0; j < 16; j++) {
                         sad += ABS(ptr_cur[0] - ptr_ref[0]);  
                         sad += ABS(ptr_cur[1] - ptr_ref[1]);  
                         sad += ABS(ptr_cur[2] - ptr_ref[2]);  
                         sad += ABS(ptr_cur[3] - ptr_ref[3]);  
                         sad += ABS(ptr_cur[4] - ptr_ref[4]);  
                         sad += ABS(ptr_cur[5] - ptr_ref[5]);  
                         sad += ABS(ptr_cur[6] - ptr_ref[6]);  
                         sad += ABS(ptr_cur[7] - ptr_ref[7]);  
                         sad += ABS(ptr_cur[8] - ptr_ref[8]);  
                         sad += ABS(ptr_cur[9] - ptr_ref[9]);  
                         sad += ABS(ptr_cur[10] - ptr_ref[10]);  
                         sad += ABS(ptr_cur[11] - ptr_ref[11]);  
                         sad += ABS(ptr_cur[12] - ptr_ref[12]);  
                         sad += ABS(ptr_cur[13] - ptr_ref[13]);  
                         sad += ABS(ptr_cur[14] - ptr_ref[14]);  
                         sad += ABS(ptr_cur[15] - ptr_ref[15]);  
127    
128                          if (sad >= best_sad)                  for (i = 0; i < 16; i++) {
129    
130                            sad += ABS(*(ptr_cur + i) - *(ptr_ref + i));
131    
132                            if (sad >= best_sad) {
133                                  return sad;                                  return sad;
134                            }
135    
136    
137                    }
138    
139                          ptr_cur += stride;                          ptr_cur += stride;
140                          ptr_ref += stride;                          ptr_ref += stride;
# Line 94  Line 145 
145    
146  }  }
147    
148    
149    
150  uint32_t  uint32_t
151  sad16bi_c(const uint8_t * const cur,  sad16bi_c(const uint8_t * const cur,
152                    const uint8_t * const ref1,                    const uint8_t * const ref1,
# Line 176  Line 229 
229             const uint32_t stride)             const uint32_t stride)
230  {  {
231          uint32_t sad = 0;          uint32_t sad = 0;
232          uint32_t j;          uint32_t i, j;
233          uint8_t const *ptr_cur = cur;          uint8_t const *ptr_cur = cur;
234          uint8_t const *ptr_ref = ref;          uint8_t const *ptr_ref = ref;
235    
236          for (j = 0; j < 8; j++) {          for (j = 0; j < 8; j++) {
237    
238                  sad += ABS(ptr_cur[0] - ptr_ref[0]);                  for (i = 0; i < 8; i++) {
239                  sad += ABS(ptr_cur[1] - ptr_ref[1]);                          sad += ABS(*(ptr_cur + i) - *(ptr_ref + i));
240                  sad += ABS(ptr_cur[2] - ptr_ref[2]);                  }
                 sad += ABS(ptr_cur[3] - ptr_ref[3]);  
                 sad += ABS(ptr_cur[4] - ptr_ref[4]);  
                 sad += ABS(ptr_cur[5] - ptr_ref[5]);  
                 sad += ABS(ptr_cur[6] - ptr_ref[6]);  
                 sad += ABS(ptr_cur[7] - ptr_ref[7]);  
241    
242                  ptr_cur += stride;                  ptr_cur += stride;
243                  ptr_ref += stride;                  ptr_ref += stride;
# Line 200  Line 248 
248  }  }
249    
250    
251    
252    
253  /* average deviation from mean */  /* average deviation from mean */
254    
255  uint32_t  uint32_t
# Line 235  Line 285 
285    
286          return dev;          return dev;
287  }  }
   
 uint32_t sad16v_c(const uint8_t * const cur,  
                            const uint8_t * const ref,  
                            const uint32_t stride,  
                            int32_t *sad)  
 {  
         sad[0] = sad8(cur, ref, stride);  
         sad[1] = sad8(cur + 8, ref + 8, stride);  
         sad[2] = sad8(cur + 8*stride, ref + 8*stride, stride);  
         sad[3] = sad8(cur + 8*stride + 8, ref + 8*stride + 8, stride);  
   
         return sad[0]+sad[1]+sad[2]+sad[3];  
 }  
   
 uint32_t sad32v_c(const uint8_t * const cur,  
                            const uint8_t * const ref,  
                            const uint32_t stride,  
                            int32_t *sad)  
 {  
         sad[0] = sad16(cur, ref, stride, 256*4096);  
         sad[1] = sad16(cur + 8, ref + 8, stride, 256*4096);  
         sad[2] = sad16(cur + 8*stride, ref + 8*stride, stride, 256*4096);  
         sad[3] = sad16(cur + 8*stride + 8, ref + 8*stride + 8, stride, 256*4096);  
   
         return sad[0]+sad[1]+sad[2]+sad[3];  
 }  
   
   
   
 #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;  
   
 }  
   
   
Legend:
Removed from v.1.7.2.2  
changed lines
  Added in v.1.11
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4