Statistics
| Branch: | Revision:

ffmpeg / postproc / cs_test.c @ b76ee469

History | View | Annotate | Download (6.39 KB)

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
static int get_sws_cpuflags()
32
{
33
    return (gCpuCaps.hasMMX ? SWS_CPU_CAPS_MMX : 0) |
34
        (gCpuCaps.hasMMX2 ? SWS_CPU_CAPS_MMX2 : 0) |
35
        (gCpuCaps.has3DNow ? SWS_CPU_CAPS_3DNOW : 0);
36
}
37

    
38
main(int argc, char **argv)
39
{
40
        int i, funcNum;
41
        uint8_t *srcBuffer= (uint8_t*)memalign(128, SIZE);
42
        uint8_t *dstBuffer= (uint8_t*)memalign(128, SIZE);
43
        int failedNum=0;
44
        int passedNum=0;
45
        
46
        printf("memory corruption test ...\n");
47
        
48
        if(argc==2){
49
                GetCpuCaps(&gCpuCaps);
50
                printf("testing mmx\n");
51
        }
52
        
53
        sws_rgb2rgb_init(get_sws_cpuflags());
54
        
55
        for(funcNum=0; funcNum<100; funcNum++){
56
                int width;
57
                int failed=0;
58
                int srcBpp=0;
59
                int dstBpp=0;
60

    
61
                printf("."); fflush(stdout);
62
                memset(srcBuffer, srcByte, SIZE);
63

    
64
                for(width=32; width<64; width++){
65
                        int dstOffset;
66
                        for(dstOffset=128; dstOffset<196; dstOffset++){
67
                                int srcOffset;
68
                                memset(dstBuffer, dstByte, SIZE);
69

    
70
                                for(srcOffset=128; srcOffset<196; srcOffset++){
71
                                        uint8_t *src= srcBuffer+srcOffset;
72
                                        uint8_t *dst= dstBuffer+dstOffset;
73
                                        char *name=NULL;
74
                                        
75
                                        if(failed) break; //dont fill the screen with shit ...
76

    
77
                                        switch(funcNum){
78
                                        case 0:
79
                                                srcBpp=2;
80
                                                dstBpp=2;
81
                                                name="rgb15to16";
82
                                                rgb15to16(src, dst, width*srcBpp);
83
                                                break;
84
                                        case 1:
85
                                                srcBpp=2;
86
                                                dstBpp=3;
87
                                                name="rgb15to24";
88
                                                rgb15to24(src, dst, width*srcBpp);
89
                                                break;
90
                                        case 2:
91
                                                srcBpp=2;
92
                                                dstBpp=4;
93
                                                name="rgb15to32";
94
                                                rgb15to32(src, dst, width*srcBpp);
95
                                                break;
96
                                        case 3:
97
                                                srcBpp=2;
98
                                                dstBpp=3;
99
                                                name="rgb16to24";
100
                                                rgb16to24(src, dst, width*srcBpp);
101
                                                break;
102
                                        case 4:
103
                                                srcBpp=2;
104
                                                dstBpp=4;
105
                                                name="rgb16to32";
106
                                                rgb16to32(src, dst, width*srcBpp);
107
                                                break;
108
                                        case 5:
109
                                                srcBpp=3;
110
                                                dstBpp=2;
111
                                                name="rgb24to15";
112
                                                rgb24to15(src, dst, width*srcBpp);
113
                                                break;
114
                                        case 6:
115
                                                srcBpp=3;
116
                                                dstBpp=2;
117
                                                name="rgb24to16";
118
                                                rgb24to16(src, dst, width*srcBpp);
119
                                                break;
120
                                        case 7:
121
                                                srcBpp=3;
122
                                                dstBpp=4;
123
                                                name="rgb24to32";
124
                                                rgb24to32(src, dst, width*srcBpp);
125
                                                break;
126
                                        case 8:
127
                                                srcBpp=4;
128
                                                dstBpp=2;
129
                                                name="rgb32to15";
130
                                                rgb32to15(src, dst, width*srcBpp);
131
                                                break;
132
                                        case 9:
133
                                                srcBpp=4;
134
                                                dstBpp=2;
135
                                                name="rgb32to16";
136
                                                rgb32to16(src, dst, width*srcBpp);
137
                                                break;
138
                                        case 10:
139
                                                srcBpp=4;
140
                                                dstBpp=3;
141
                                                name="rgb32to24";
142
                                                rgb32to24(src, dst, width*srcBpp);
143
                                                break;
144
                                        case 11:
145
                                                srcBpp=2;
146
                                                dstBpp=2;
147
                                                name="rgb16to15";
148
                                                rgb16to15(src, dst, width*srcBpp);
149
                                                break;
150
                                        
151
                                        case 14:
152
                                                srcBpp=2;
153
                                                dstBpp=2;
154
                                                name="rgb15tobgr15";
155
                                                rgb15tobgr15(src, dst, width*srcBpp);
156
                                                break;
157
                                        case 15:
158
                                                srcBpp=2;
159
                                                dstBpp=2;
160
                                                name="rgb15tobgr16";
161
                                                rgb15tobgr16(src, dst, width*srcBpp);
162
                                                break;
163
                                        case 16:
164
                                                srcBpp=2;
165
                                                dstBpp=3;
166
                                                name="rgb15tobgr24";
167
                                                rgb15tobgr24(src, dst, width*srcBpp);
168
                                                break;
169
                                        case 17:
170
                                                srcBpp=2;
171
                                                dstBpp=4;
172
                                                name="rgb15tobgr32";
173
                                                rgb15tobgr32(src, dst, width*srcBpp);
174
                                                break;
175
                                        case 18:
176
                                                srcBpp=2;
177
                                                dstBpp=2;
178
                                                name="rgb16tobgr15";
179
                                                rgb16tobgr15(src, dst, width*srcBpp);
180
                                                break;
181
                                        case 19:
182
                                                srcBpp=2;
183
                                                dstBpp=2;
184
                                                name="rgb16tobgr16";
185
                                                rgb16tobgr16(src, dst, width*srcBpp);
186
                                                break;
187
                                        case 20:
188
                                                srcBpp=2;
189
                                                dstBpp=3;
190
                                                name="rgb16tobgr24";
191
                                                rgb16tobgr24(src, dst, width*srcBpp);
192
                                                break;
193
                                        case 21:
194
                                                srcBpp=2;
195
                                                dstBpp=4;
196
                                                name="rgb16tobgr32";
197
                                                rgb16tobgr32(src, dst, width*srcBpp);
198
                                                break;
199
                                        case 22:
200
                                                srcBpp=3;
201
                                                dstBpp=2;
202
                                                name="rgb24tobgr15";
203
                                                rgb24tobgr15(src, dst, width*srcBpp);
204
                                                break;
205
                                        case 23:
206
                                                srcBpp=3;
207
                                                dstBpp=2;
208
                                                name="rgb24tobgr16";
209
                                                rgb24tobgr16(src, dst, width*srcBpp);
210
                                                break;
211
                                        case 24:
212
                                                srcBpp=3;
213
                                                dstBpp=3;
214
                                                name="rgb24tobgr24";
215
                                                rgb24tobgr24(src, dst, width*srcBpp);
216
                                                break;
217
                                        case 25:
218
                                                srcBpp=3;
219
                                                dstBpp=4;
220
                                                name="rgb24tobgr32";
221
                                                rgb24tobgr32(src, dst, width*srcBpp);
222
                                                break;
223
                                        case 26:
224
                                                srcBpp=4;
225
                                                dstBpp=2;
226
                                                name="rgb32tobgr15";
227
                                                rgb32tobgr15(src, dst, width*srcBpp);
228
                                                break;
229
                                        case 27:
230
                                                srcBpp=4;
231
                                                dstBpp=2;
232
                                                name="rgb32tobgr16";
233
                                                rgb32tobgr16(src, dst, width*srcBpp);
234
                                                break;
235
                                        case 28:
236
                                                srcBpp=4;
237
                                                dstBpp=3;
238
                                                name="rgb32tobgr24";
239
                                                rgb32tobgr24(src, dst, width*srcBpp);
240
                                                break;
241
                                        case 29:
242
                                                srcBpp=4;
243
                                                dstBpp=4;
244
                                                name="rgb32tobgr32";
245
                                                rgb32tobgr32(src, dst, width*srcBpp);
246
                                                break;
247

    
248
                                        }
249
                                        if(!srcBpp) break;
250

    
251
                                        for(i=0; i<SIZE; i++){
252
                                                if(srcBuffer[i]!=srcByte){
253
                                                        printf("src damaged at %d w:%d src:%d dst:%d %s\n", 
254
                                                                i, width, srcOffset, dstOffset, name);
255
                                                        failed=1;
256
                                                        break;
257
                                                }
258
                                        }
259
                                        for(i=0; i<dstOffset; i++){
260
                                                if(dstBuffer[i]!=dstByte){
261
                                                        printf("dst damaged at %d w:%d src:%d dst:%d %s\n", 
262
                                                                i, width, srcOffset, dstOffset, name);
263
                                                        failed=1;
264
                                                        break;
265
                                                }
266
                                        }
267
                                        for(i=dstOffset + width*dstBpp; i<SIZE; i++){
268
                                                if(dstBuffer[i]!=dstByte){
269
                                                        printf("dst damaged at %d w:%d src:%d dst:%d %s\n", 
270
                                                                i, width, srcOffset, dstOffset, name);
271
                                                        failed=1;
272
                                                        break;
273
                                                }
274
                                        }
275
                                }
276
                        }
277
                }
278
                if(failed) failedNum++;
279
                else if(srcBpp) passedNum++;
280
        }
281
        
282
        printf("%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum);
283
        return failedNum;
284
}