[svn] / trunk / xvidcore / src / utils / mem_transfer.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/utils/mem_transfer.c

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

revision 195, Wed Jun 12 20:38:41 2002 UTC revision 1627, Mon Aug 1 10:53:46 2005 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      8bit<->16bit transfer   *  - 8bit<->16bit transfer  -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2001-2003 Peter Ross <pross@xvid.org>
  *      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 24  Line 17 
17   *   *
18   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
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., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *  
  *************************************************************************/  
   
 /**************************************************************************  
21   *   *
22   *      History:   * $Id: mem_transfer.c,v 1.15 2005-08-01 10:53:46 Isibaar Exp $
23   *   *
24   *      14.04.2002      added transfer_8to16sub2   ****************************************************************************/
25   *      07.01.2002      merge functions from compensate; rename functions  
26   *      22.12.2001      transfer_8to8add16 limit fix  #include "../global.h"
27   *      07.11.2001      initial version; (c)2001 peter ross <pross@cs.rmit.edu.au>  #include "mem_transfer.h"
28    
29   *************************************************************************/  /* Function pointers - Initialized in the xvid.c module */
30    
31    TRANSFER_8TO16COPY_PTR transfer_8to16copy;
32    TRANSFER_16TO8COPY_PTR transfer_16to8copy;
33    
34  TRANSFER_8TO16SUB_PTR  transfer_8to16sub;  TRANSFER_8TO16SUB_PTR  transfer_8to16sub;
35    TRANSFER_8TO16SUBRO_PTR  transfer_8to16subro;
36  TRANSFER_8TO16SUB2_PTR transfer_8to16sub2;  TRANSFER_8TO16SUB2_PTR transfer_8to16sub2;
37    TRANSFER_8TO16SUB2RO_PTR transfer_8to16sub2ro;
38  TRANSFER_16TO8ADD_PTR  transfer_16to8add;  TRANSFER_16TO8ADD_PTR  transfer_16to8add;
39    
40  // function pointers  TRANSFER8X8_COPY_PTR transfer8x8_copy;
41    
42    #define USE_REFERENCE_C
43    
44  /*****************************************************************************  /*****************************************************************************
45   *   *
46  TRANSFER_8TO16SUB_PTR transfer_8to16sub;   * All these functions are used to transfer data from a 8 bit data array
47   * to a 16 bit data array.   * to a 16 bit data array.
48  TRANSFER_16TO8ADD_PTR transfer_16to8add;   *
49   * This is typically used during motion compensation, that's why some   * This is typically used during motion compensation, that's why some
50   * functions also do the addition/substraction of another buffer during the   * functions also do the addition/substraction of another buffer during the
51   * so called  transfer.   * so called  transfer.
52   *   *
53     ****************************************************************************/
54    
55    /*
56     * SRC - the source buffer
57     * DST - the destination buffer
58     *
59     * Then the function does the 8->16 bit transfer and this serie of operations :
60     *
61     *    SRC (8bit)  = SRC
62     *    DST (16bit) = SRC
63   */   */
64    void
65    transfer_8to16copy_c(int16_t * const dst,
66                                             const uint8_t * const src,
67                                             uint32_t stride)
68    {
69            int i, j;
70            for (j = 0; j < 8; j++) {
71                    for (i = 0; i < 8; i++) {
72                          dst[j * 8 + i] = (int16_t) src[j * stride + i];                          dst[j * 8 + i] = (int16_t) src[j * stride + i];
73                  }                  }
74          }          }
# Line 69  Line 83 
83   *    SRC (16bit) = SRC   *    SRC (16bit) = SRC
84   *    DST (8bit)  = max(min(SRC, 255), 0)   *    DST (8bit)  = max(min(SRC, 255), 0)
85   */   */
86    void
87    transfer_16to8copy_c(uint8_t * const dst,
88                                             const int16_t * const src,
89                                             uint32_t stride)
90    {
91            int i, j;
92    
93            for (j = 0; j < 8; j++) {
94                    for (i = 0; i < 8; i++) {
95    #ifdef USE_REFERENCE_C
96                          int16_t pixel = src[j * 8 + i];                          int16_t pixel = src[j * 8 + i];
97    
98                          if (pixel < 0) {                          if (pixel < 0) {
# Line 78  Line 101 
101                                  pixel = 255;                                  pixel = 255;
102                          }                          }
103                          dst[j * stride + i] = (uint8_t) pixel;                          dst[j * stride + i] = (uint8_t) pixel;
104    #else
105                            const int16_t pixel = src[j * 8 + i];
106                            const uint8_t value = (uint8_t)( (pixel&~255) ? (-pixel)>>(8*sizeof(pixel)-1) : pixel );
107                            dst[j*stride + i] = value;
108    #endif
109                  }                  }
110          }          }
111  }  }
# Line 95  Line 123 
123   *    R   (8bit)  = R   *    R   (8bit)  = R
124   *    C   (8bit)  = R   *    C   (8bit)  = R
125   *    DCT (16bit) = C - R   *    DCT (16bit) = C - R
   perform motion compensation (and 8bit->16bit dct transfer)  
   ... with write back  
126  */  */
127    void
128    transfer_8to16sub_c(int16_t * const dct,
129                                            uint8_t * const cur,
130                                            const uint8_t * ref,
131                                            const uint32_t stride)
132    {
133            int i, j;
134    
135            for (j = 0; j < 8; j++) {
136                  for (i = 0; i < 8; i++) {                  for (i = 0; i < 8; i++) {
137                          uint8_t c = cur[j * stride + i];                          const uint8_t c = cur[j * stride + i];
138                          uint8_t r = ref[j * stride + i];                          const uint8_t r = ref[j * stride + i];
139    
140                          cur[j * stride + i] = r;                          cur[j * stride + i] = r;
141                          dct[j * 8 + i] = (int16_t) c - (int16_t) r;                          dct[j * 8 + i] = (int16_t) c - (int16_t) r;
# Line 109  Line 144 
144  }  }
145    
146    
147    void
148    transfer_8to16subro_c(int16_t * const dct,
149                                            const uint8_t * const cur,
150                                            const uint8_t * ref,
151                                            const uint32_t stride)
152    {
153            int i, j;
154    
155            for (j = 0; j < 8; j++) {
156                    for (i = 0; i < 8; i++) {
157                            const uint8_t c = cur[j * stride + i];
158                            const uint8_t r = ref[j * stride + i];
159                            dct[j * 8 + i] = (int16_t) c - (int16_t) r;
160                    }
161            }
162    }
163    
164    
165    
166  /*  /*
167   * C   - the current buffer   * C   - the current buffer
168   * R1  - the 1st reference buffer   * R1  - the 1st reference buffer
# Line 119  Line 173 
173   *   *
174   *    R1  (8bit) = R1   *    R1  (8bit) = R1
175   *    R2  (8bit) = R2   *    R2  (8bit) = R2
176    performs bi motion compensation (and 8bit->16bit dct transfer)   *    R   (temp) = min((R1 + R2)/2, 255)
177    .. but does not write back   *    DCT (16bit)= C - R
178     *    C   (8bit) = R
179  */  */
180    void
181    transfer_8to16sub2_c(int16_t * const dct,
182                                             uint8_t * const cur,
183                                             const uint8_t * ref1,
184                                             const uint8_t * ref2,
185                                             const uint32_t stride)
186    {
187            uint32_t i, j;
188    
189          for (j = 0; j < 8; j++) {          for (j = 0; j < 8; j++) {
190                  for (i = 0; i < 8; i++) {                  for (i = 0; i < 8; i++) {
191                          uint8_t c = cur[j * stride + i];                          const uint8_t c = cur[j * stride + i];
192                          int r = (ref1[j * stride + i] + ref2[j * stride + i] + 1) / 2;                          const uint8_t r = (ref1[j * stride + i] + ref2[j * stride + i] + 1) >> 1;
193                            cur[j * stride + i] = r;
194                          if (r > 255) {                          dct[j * 8 + i] = (int16_t) c - (int16_t) r;
                                 r = 255;  
195                          }                          }
196                          //cur[j * stride + i] = r;          }
197    }
198    
199    void
200    transfer_8to16sub2ro_c(int16_t * const dct,
201                                             const uint8_t * const cur,
202                                             const uint8_t * ref1,
203                                             const uint8_t * ref2,
204                                             const uint32_t stride)
205    {
206            uint32_t i, j;
207    
208            for (j = 0; j < 8; j++) {
209                    for (i = 0; i < 8; i++) {
210                            const uint8_t c = cur[j * stride + i];
211                            const uint8_t r = (ref1[j * stride + i] + ref2[j * stride + i] + 1) >> 1;
212                          dct[j * 8 + i] = (int16_t) c - (int16_t) r;                          dct[j * 8 + i] = (int16_t) c - (int16_t) r;
213                  }                  }
214          }          }
# Line 146  Line 224 
224   *    SRC (16bit) = SRC   *    SRC (16bit) = SRC
225   *    DST (8bit)  = max(min(DST+SRC, 255), 0)   *    DST (8bit)  = max(min(DST+SRC, 255), 0)
226   */   */
227    void
228    transfer_16to8add_c(uint8_t * const dst,
229                                            const int16_t * const src,
230                                            uint32_t stride)
231    {
232            int i, j;
233    
234            for (j = 0; j < 8; j++) {
235                    for (i = 0; i < 8; i++) {
236    #ifdef USE_REFERENCE_C
237                          int16_t pixel = (int16_t) dst[j * stride + i] + src[j * 8 + i];                          int16_t pixel = (int16_t) dst[j * stride + i] + src[j * 8 + i];
238    
239                          if (pixel < 0) {                          if (pixel < 0) {
# Line 154  Line 242 
242                                  pixel = 255;                                  pixel = 255;
243                          }                          }
244                          dst[j * stride + i] = (uint8_t) pixel;                          dst[j * stride + i] = (uint8_t) pixel;
245    #else
246          const int16_t pixel = (int16_t) dst[j * stride + i] + src[j * 8 + i];
247                            const uint8_t value = (uint8_t)( (pixel&~255) ? (-pixel)>>(8*sizeof(pixel)-1) : pixel );
248                            dst[j*stride + i] = value;
249    #endif
250    
251                  }                  }
252          }          }
253  }  }
# Line 167  Line 261 
261   *    SRC (8bit) = SRC   *    SRC (8bit) = SRC
262   *    DST (8bit) = SRC   *    DST (8bit) = SRC
263   */   */
264    void
265    transfer8x8_copy_c(uint8_t * const dst,
266                                       const uint8_t * const src,
267                          dst[j * stride + i] = src[j * stride + i];                                     const uint32_t stride)
268    {
269            int j, i;
270    
271            for (j = 0; j < 8; ++j) {
272                uint8_t *d = dst + j*stride;
273                    const uint8_t *s = src + j*stride;
274    
275                    for (i = 0; i < 8; ++i)
276                    {
277                            *d++ = *s++;
278                  }                  }
279          }          }
280  }  }
Legend:
Removed from v.195  
changed lines
  Added in v.1627
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4