b1963f92f62a42f4ac173e2e3185762e506d266b
[ffmpeg.git] / libswscale / cs_test.c
1 /*
2     Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at>
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <inttypes.h>
22
23 #include "swscale.h"
24 #include "rgb2rgb.h"
25 #include "cpudetect.h"
26
27 #define SIZE 1000
28 #define srcByte 0x55
29 #define dstByte 0xBB
30
31 #ifdef __APPLE_CC__
32 #define memalign(x,y) malloc(y)
33 #endif
34
35 static int get_sws_cpuflags()
36 {
37     return (gCpuCaps.hasMMX ? SWS_CPU_CAPS_MMX : 0) |
38         (gCpuCaps.hasMMX2 ? SWS_CPU_CAPS_MMX2 : 0) |
39         (gCpuCaps.has3DNow ? SWS_CPU_CAPS_3DNOW : 0);
40 }
41
42 main(int argc, char **argv)
43 {
44         int i, funcNum;
45         uint8_t *srcBuffer= (uint8_t*)memalign(128, SIZE);
46         uint8_t *dstBuffer= (uint8_t*)memalign(128, SIZE);
47         int failedNum=0;
48         int passedNum=0;
49         
50         printf("memory corruption test ...\n");
51         
52         if(argc==2){
53                 GetCpuCaps(&gCpuCaps);
54                 printf("testing mmx\n");
55         }
56         
57         sws_rgb2rgb_init(get_sws_cpuflags());
58         
59         for(funcNum=0; funcNum<100; funcNum++){
60                 int width;
61                 int failed=0;
62                 int srcBpp=0;
63                 int dstBpp=0;
64
65                 printf("."); fflush(stdout);
66                 memset(srcBuffer, srcByte, SIZE);
67
68                 for(width=32; width<64; width++){
69                         int dstOffset;
70                         for(dstOffset=128; dstOffset<196; dstOffset++){
71                                 int srcOffset;
72                                 memset(dstBuffer, dstByte, SIZE);
73
74                                 for(srcOffset=128; srcOffset<196; srcOffset++){
75                                         uint8_t *src= srcBuffer+srcOffset;
76                                         uint8_t *dst= dstBuffer+dstOffset;
77                                         char *name=NULL;
78                                         
79                                         if(failed) break; //don't fill the screen with shit ...
80
81                                         switch(funcNum){
82                                         case 0:
83                                                 srcBpp=2;
84                                                 dstBpp=2;
85                                                 name="rgb15to16";
86                                                 rgb15to16(src, dst, width*srcBpp);
87                                                 break;
88                                         case 1:
89                                                 srcBpp=2;
90                                                 dstBpp=3;
91                                                 name="rgb15to24";
92                                                 rgb15to24(src, dst, width*srcBpp);
93                                                 break;
94                                         case 2:
95                                                 srcBpp=2;
96                                                 dstBpp=4;
97                                                 name="rgb15to32";
98                                                 rgb15to32(src, dst, width*srcBpp);
99                                                 break;
100                                         case 3:
101                                                 srcBpp=2;
102                                                 dstBpp=3;
103                                                 name="rgb16to24";
104                                                 rgb16to24(src, dst, width*srcBpp);
105                                                 break;
106                                         case 4:
107                                                 srcBpp=2;
108                                                 dstBpp=4;
109                                                 name="rgb16to32";
110                                                 rgb16to32(src, dst, width*srcBpp);
111                                                 break;
112                                         case 5:
113                                                 srcBpp=3;
114                                                 dstBpp=2;
115                                                 name="rgb24to15";
116                                                 rgb24to15(src, dst, width*srcBpp);
117                                                 break;
118                                         case 6:
119                                                 srcBpp=3;
120                                                 dstBpp=2;
121                                                 name="rgb24to16";
122                                                 rgb24to16(src, dst, width*srcBpp);
123                                                 break;
124                                         case 7:
125                                                 srcBpp=3;
126                                                 dstBpp=4;
127                                                 name="rgb24to32";
128                                                 rgb24to32(src, dst, width*srcBpp);
129                                                 break;
130                                         case 8:
131                                                 srcBpp=4;
132                                                 dstBpp=2;
133                                                 name="rgb32to15";
134                                                 rgb32to15(src, dst, width*srcBpp);
135                                                 break;
136                                         case 9:
137                                                 srcBpp=4;
138                                                 dstBpp=2;
139                                                 name="rgb32to16";
140                                                 rgb32to16(src, dst, width*srcBpp);
141                                                 break;
142                                         case 10:
143                                                 srcBpp=4;
144                                                 dstBpp=3;
145                                                 name="rgb32to24";
146                                                 rgb32to24(src, dst, width*srcBpp);
147                                                 break;
148                                         case 11:
149                                                 srcBpp=2;
150                                                 dstBpp=2;
151                                                 name="rgb16to15";
152                                                 rgb16to15(src, dst, width*srcBpp);
153                                                 break;
154                                         
155                                         case 14:
156                                                 srcBpp=2;
157                                                 dstBpp=2;
158                                                 name="rgb15tobgr15";
159                                                 rgb15tobgr15(src, dst, width*srcBpp);
160                                                 break;
161                                         case 15:
162                                                 srcBpp=2;
163                                                 dstBpp=2;
164                                                 name="rgb15tobgr16";
165                                                 rgb15tobgr16(src, dst, width*srcBpp);
166                                                 break;
167                                         case 16:
168                                                 srcBpp=2;
169                                                 dstBpp=3;
170                                                 name="rgb15tobgr24";
171                                                 rgb15tobgr24(src, dst, width*srcBpp);
172                                                 break;
173                                         case 17:
174                                                 srcBpp=2;
175                                                 dstBpp=4;
176                                                 name="rgb15tobgr32";
177                                                 rgb15tobgr32(src, dst, width*srcBpp);
178                                                 break;
179                                         case 18:
180                                                 srcBpp=2;
181                                                 dstBpp=2;
182                                                 name="rgb16tobgr15";
183                                                 rgb16tobgr15(src, dst, width*srcBpp);
184                                                 break;
185                                         case 19:
186                                                 srcBpp=2;
187                                                 dstBpp=2;
188                                                 name="rgb16tobgr16";
189                                                 rgb16tobgr16(src, dst, width*srcBpp);
190                                                 break;
191                                         case 20:
192                                                 srcBpp=2;
193                                                 dstBpp=3;
194                                                 name="rgb16tobgr24";
195                                                 rgb16tobgr24(src, dst, width*srcBpp);
196                                                 break;
197                                         case 21:
198                                                 srcBpp=2;
199                                                 dstBpp=4;
200                                                 name="rgb16tobgr32";
201                                                 rgb16tobgr32(src, dst, width*srcBpp);
202                                                 break;
203                                         case 22:
204                                                 srcBpp=3;
205                                                 dstBpp=2;
206                                                 name="rgb24tobgr15";
207                                                 rgb24tobgr15(src, dst, width*srcBpp);
208                                                 break;
209                                         case 23:
210                                                 srcBpp=3;
211                                                 dstBpp=2;
212                                                 name="rgb24tobgr16";
213                                                 rgb24tobgr16(src, dst, width*srcBpp);
214                                                 break;
215                                         case 24:
216                                                 srcBpp=3;
217                                                 dstBpp=3;
218                                                 name="rgb24tobgr24";
219                                                 rgb24tobgr24(src, dst, width*srcBpp);
220                                                 break;
221                                         case 25:
222                                                 srcBpp=3;
223                                                 dstBpp=4;
224                                                 name="rgb24tobgr32";
225                                                 rgb24tobgr32(src, dst, width*srcBpp);
226                                                 break;
227                                         case 26:
228                                                 srcBpp=4;
229                                                 dstBpp=2;
230                                                 name="rgb32tobgr15";
231                                                 rgb32tobgr15(src, dst, width*srcBpp);
232                                                 break;
233                                         case 27:
234                                                 srcBpp=4;
235                                                 dstBpp=2;
236                                                 name="rgb32tobgr16";
237                                                 rgb32tobgr16(src, dst, width*srcBpp);
238                                                 break;
239                                         case 28:
240                                                 srcBpp=4;
241                                                 dstBpp=3;
242                                                 name="rgb32tobgr24";
243                                                 rgb32tobgr24(src, dst, width*srcBpp);
244                                                 break;
245                                         case 29:
246                                                 srcBpp=4;
247                                                 dstBpp=4;
248                                                 name="rgb32tobgr32";
249                                                 rgb32tobgr32(src, dst, width*srcBpp);
250                                                 break;
251
252                                         }
253                                         if(!srcBpp) break;
254
255                                         for(i=0; i<SIZE; i++){
256                                                 if(srcBuffer[i]!=srcByte){
257                                                         printf("src damaged at %d w:%d src:%d dst:%d %s\n", 
258                                                                 i, width, srcOffset, dstOffset, name);
259                                                         failed=1;
260                                                         break;
261                                                 }
262                                         }
263                                         for(i=0; i<dstOffset; i++){
264                                                 if(dstBuffer[i]!=dstByte){
265                                                         printf("dst damaged at %d w:%d src:%d dst:%d %s\n", 
266                                                                 i, width, srcOffset, dstOffset, name);
267                                                         failed=1;
268                                                         break;
269                                                 }
270                                         }
271                                         for(i=dstOffset + width*dstBpp; i<SIZE; i++){
272                                                 if(dstBuffer[i]!=dstByte){
273                                                         printf("dst damaged at %d w:%d src:%d dst:%d %s\n", 
274                                                                 i, width, srcOffset, dstOffset, name);
275                                                         failed=1;
276                                                         break;
277                                                 }
278                                         }
279                                 }
280                         }
281                 }
282                 if(failed) failedNum++;
283                 else if(srcBpp) passedNum++;
284         }
285         
286         printf("%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum);
287         return failedNum;
288 }