git.sesse.net Git - ffmpeg/blob - 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., 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; //don't 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 }