← Back to branch summary

~ubuntu-dev/mplayer/ubuntu-feisty

« back to all changes in this revision

Viewing changes to postproc/cs_test.c

  • Committer: Reinhard Tartler
  • Date: 2006-07-08 08:45:33 UTC
  • Revision ID: siretart@tauware.de-20060708084533-dbc155bde7122e78
imported mplayer_0.99+1.0pre7try2+cvs20060117

Show diffs side-by-side

added added

removed removed

Lines of Context:
postproc/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
}