Statistics
| Branch: | Revision:

ffmpeg / libswscale / colorspace-test.c @ 5d6e4c16

History | View | Annotate | Download (5.72 KB)

1
/*
2
 * Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at>
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20

    
21
#include <stdio.h>
22
#include <string.h>              /* for memset() */
23
#include <unistd.h>
24
#include <stdlib.h>
25
#include <inttypes.h>
26

    
27
#include "swscale.h"
28
#include "rgb2rgb.h"
29

    
30
#define SIZE 1000
31
#define srcByte 0x55
32
#define dstByte 0xBB
33

    
34
#define FUNC(s,d,n) {s,d,#n,n}
35

    
36
static int cpu_caps;
37

    
38
static char *args_parse(int argc, char *argv[])
39
{
40
    int o;
41

    
42
    while ((o = getopt(argc, argv, "m23")) != -1) {
43
        switch (o) {
44
        case 'm':
45
            cpu_caps |= SWS_CPU_CAPS_MMX;
46
            break;
47
        case '2':
48
            cpu_caps |= SWS_CPU_CAPS_MMX2;
49
            break;
50
        case '3':
51
            cpu_caps |= SWS_CPU_CAPS_3DNOW;
52
            break;
53
        default:
54
            av_log(NULL, AV_LOG_ERROR, "Unknown option %c\n", o);
55
        }
56
    }
57

    
58
    return argv[optind];
59
}
60

    
61
int main(int argc, char **argv)
62
{
63
    int i, funcNum;
64
    uint8_t *srcBuffer= (uint8_t*)av_malloc(SIZE);
65
    uint8_t *dstBuffer= (uint8_t*)av_malloc(SIZE);
66
    int failedNum=0;
67
    int passedNum=0;
68

    
69
    if (!srcBuffer || !dstBuffer)
70
        return -1;
71

    
72
    av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n");
73
    args_parse(argc, argv);
74
    av_log(NULL, AV_LOG_INFO, "CPU capabilities forced to %x\n", cpu_caps);
75
    sws_rgb2rgb_init(cpu_caps);
76

    
77
    for(funcNum=0; ; funcNum++) {
78
        struct func_info_s {
79
            int src_bpp;
80
            int dst_bpp;
81
            const char *name;
82
            void (*func)(const uint8_t *src, uint8_t *dst, long src_size);
83
        } func_info[] = {
84
            FUNC(2, 2, rgb15to16),
85
            FUNC(2, 3, rgb15to24),
86
            FUNC(2, 4, rgb15to32),
87
            FUNC(2, 3, rgb16to24),
88
            FUNC(2, 4, rgb16to32),
89
            FUNC(3, 2, rgb24to15),
90
            FUNC(3, 2, rgb24to16),
91
            FUNC(3, 4, rgb24to32),
92
            FUNC(4, 2, rgb32to15),
93
            FUNC(4, 2, rgb32to16),
94
            FUNC(4, 3, rgb32to24),
95
            FUNC(2, 2, rgb16to15),
96
            FUNC(2, 2, rgb15tobgr15),
97
            FUNC(2, 2, rgb15tobgr16),
98
            FUNC(2, 3, rgb15tobgr24),
99
            FUNC(2, 4, rgb15tobgr32),
100
            FUNC(2, 2, rgb16tobgr15),
101
            FUNC(2, 2, rgb16tobgr16),
102
            FUNC(2, 3, rgb16tobgr24),
103
            FUNC(2, 4, rgb16tobgr32),
104
            FUNC(3, 2, rgb24tobgr15),
105
            FUNC(3, 2, rgb24tobgr16),
106
            FUNC(3, 3, rgb24tobgr24),
107
            FUNC(3, 4, rgb24tobgr32),
108
            FUNC(4, 2, rgb32tobgr15),
109
            FUNC(4, 2, rgb32tobgr16),
110
            FUNC(4, 3, rgb32tobgr24),
111
            FUNC(4, 4, rgb32tobgr32),
112
            FUNC(0, 0, NULL)
113
        };
114
        int width;
115
        int failed=0;
116
        int srcBpp=0;
117
        int dstBpp=0;
118

    
119
        if (!func_info[funcNum].func) break;
120

    
121
        av_log(NULL, AV_LOG_INFO,".");
122
        memset(srcBuffer, srcByte, SIZE);
123

    
124
        for(width=63; width>0; width--) {
125
            int dstOffset;
126
            for(dstOffset=128; dstOffset<196; dstOffset+=4) {
127
                int srcOffset;
128
                memset(dstBuffer, dstByte, SIZE);
129

    
130
                for(srcOffset=128; srcOffset<196; srcOffset+=4) {
131
                    uint8_t *src= srcBuffer+srcOffset;
132
                    uint8_t *dst= dstBuffer+dstOffset;
133
                    const char *name=NULL;
134

    
135
                    if(failed) break; //don't fill the screen with shit ...
136

    
137
                    srcBpp = func_info[funcNum].src_bpp;
138
                    dstBpp = func_info[funcNum].dst_bpp;
139
                    name   = func_info[funcNum].name;
140

    
141
                    func_info[funcNum].func(src, dst, width*srcBpp);
142

    
143
                    if(!srcBpp) break;
144

    
145
                    for(i=0; i<SIZE; i++) {
146
                        if(srcBuffer[i]!=srcByte) {
147
                            av_log(NULL, AV_LOG_INFO, "src damaged at %d w:%d src:%d dst:%d %s\n",
148
                                   i, width, srcOffset, dstOffset, name);
149
                            failed=1;
150
                            break;
151
                        }
152
                    }
153
                    for(i=0; i<dstOffset; i++) {
154
                        if(dstBuffer[i]!=dstByte) {
155
                            av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n",
156
                                   i, width, srcOffset, dstOffset, name);
157
                            failed=1;
158
                            break;
159
                        }
160
                    }
161
                    for(i=dstOffset + width*dstBpp; i<SIZE; i++) {
162
                        if(dstBuffer[i]!=dstByte) {
163
                            av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n",
164
                                   i, width, srcOffset, dstOffset, name);
165
                            failed=1;
166
                            break;
167
                        }
168
                    }
169
                }
170
            }
171
        }
172
        if(failed) failedNum++;
173
        else if(srcBpp) passedNum++;
174
    }
175

    
176
    av_log(NULL, AV_LOG_INFO, "\n%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum);
177
    return failedNum;
178
}