test/patchrgbconv.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define __OOP_NOATTRBASES__
   7
   8 #include <proto/dos.h>
   9 #include <proto/graphics.h>
  10 #include <proto/intuition.h>
  11 #include <proto/oop.h>
  12 #include <dos/rdargs.h>
  13 #include <hidd/graphics.h>
  14 #include <aros/macros.h>
  15 #include <aros/debug.h>
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19
  20 static BOOL noisy;
  21
  22 #include "patchrgbconv_macros.h"
  23 #include "patchrgbconv_rgbswap.h"
  24 #include "patchrgbconv_argb32.h"
  25 #include "patchrgbconv_bgra32.h"
  26 #include "patchrgbconv_rgba32.h"
  27 #include "patchrgbconv_abgr32.h"
  28 #include "patchrgbconv_rgb24.h"
  29 #include "patchrgbconv_bgr24.h"
  30 #include "patchrgbconv_rgb15.h"
  31 #include "patchrgbconv_bgr15.h"
  32 #include "patchrgbconv_rgb16.h"
  33 #include "patchrgbconv_bgr16.h"
  34 #include "patchrgbconv_rgb16oe.h"
  35 #include "patchrgbconv_bgr16oe.h"
  36 #include "patchrgbconv_rgb15oe.h"
  37 #include "patchrgbconv_bgr15oe.h"
  38 #include "patchrgbconv_xrgb32.h"
  39 #include "patchrgbconv_bgrx32.h"
  40 #include "patchrgbconv_rgbx32.h"
  41 #include "patchrgbconv_xbgr32.h"
  42
  43 #include "patchrgbconv_verify.h"
  44
  45 #define VERIFY_SIZE 100
  46
  47 #define ARG_TEMPLATE "VERIFY=V/S,BENCH=B/N/K,NOISY=N/S"
  48 #define ARG_VERIFY 0
  49 #define ARG_BENCH 1
  50 #define ARG_NOISY 2
  51 #define ARG_NUM 3
  52
  53 #undef ConvertPixels
  54
  55 static OOP_AttrBase HiddBitMapAttrBase;
  56
  57 static IPTR args[ARG_NUM];
  58
  59 static ULONG dstbuf_orig[VERIFY_SIZE * 4 + 10];
  60 static ULONG dstbuf_new[VERIFY_SIZE * 4 + 10];
  61 static UBYTE *benchmem;
  62
  63 static void dumpmem(UBYTE *buf, ULONG num, ULONG size, STRPTR info)
  64 {
  65     int i, b;
  66
  67     bug("  %s", info);
  68
  69     for(i = 0; i < num; i++)
  70     {
  71         if ((i % (32 / size)) == 0)
  72         {
  73             bug("\n   ");
  74         }
  75
  76         for(b = 0; b < size; b++)
  77         {
  78         #if AROS_BIG_ENDAIN
  79             bug("%02x", buf[b]);
  80         #else
  81             bug("%02x", buf[size - 1 -b]);
  82         #endif
  83         }
  84         buf += size;
  85         bug(" ");
  86     }
  87     bug("\n\n");
  88 }
  89
  90 void ConvertPixels(APTR srcPixels, ULONG srcMod, HIDDT_StdPixFmt srcPixFmt,
  91                    APTR dstPixels, ULONG dstMod, HIDDT_StdPixFmt dstPixFmt,
  92                    ULONG width, ULONG height, OOP_Object *bm)
  93 {
  94     OOP_Object *gfxhidd = NULL;
  95     OOP_Object *srcpf, *dstpf;
  96     APTR src = srcPixels;
  97     APTR dst = dstPixels;
  98
  99     OOP_GetAttr(bm, aHidd_BitMap_GfxHidd, (IPTR *)&gfxhidd);
 100
 101     if (!gfxhidd) {
 102         bug("ConvertPixels(): Failed to obtain graphics driver\n");
 103         return;
 104     }
 105
 106     srcpf = HIDD_Gfx_GetPixFmt(gfxhidd, srcPixFmt);
 107     dstpf = HIDD_Gfx_GetPixFmt(gfxhidd, dstPixFmt);
 108
 109     if (!srcpf || !dstpf)
 110     {
 111         bug("ConvertPixels(): Bad source (%d) or dest (%d) pixfmt!\n", srcPixFmt, dstPixFmt);
 112         return;
 113     }
 114
 115     HIDD_BM_ConvertPixels(bm, &src, (HIDDT_PixelFormat *)srcpf, srcMod,
 116                           &dst, (HIDDT_PixelFormat *)dstpf, dstMod,
 117                           width, height, NULL);
 118 }
 119
 120 typedef void (*DOFUNC)(ULONG srcfmt, ULONG dstfmt, ULONG srcbits, ULONG dstbits,
 121                        HIDDT_RGBConversionFunction f, BOOL verify, ULONG bench,
 122                        APTR testpixels, ULONG numtestpixels, char *srcfmt_string,
 123                        char *dstfmt_string, OOP_Object *bm);
 124
 125 static void uninstallfunc(ULONG srcfmt, ULONG dstfmt, ULONG srcbits, ULONG dstbits,
 126                           HIDDT_RGBConversionFunction f, BOOL verify, ULONG bench,
 127                           APTR testpixels, ULONG numtestpixels, char *srcfmt_string,
 128                           char *dstfmt_string, OOP_Object *bm)
 129 {
 130     (void)srcbits;
 131     (void)dstbits;
 132     (void)(f);
 133     (void)verify;
 134     (void)bench;
 135     (void)testpixels;
 136     (void)numtestpixels;
 137     (void)srcfmt_string;
 138     (void)dstfmt_string;
 139
 140     HIDD_BM_SetRGBConversionFunction(bm, srcfmt, dstfmt, NULL);
 141 }
 142
 143
 144 static void installfunc(ULONG srcfmt, ULONG dstfmt, ULONG srcbits, ULONG dstbits,
 145                         HIDDT_RGBConversionFunction f, BOOL verify, ULONG bench,
 146                         APTR testpixels, ULONG numtestpixels, char *srcfmt_string,
 147                         char *dstfmt_string, OOP_Object *bm)
 148 {
 149     ULONG srcbytes, dstbytes;
 150     ULONG sec1, sec2, micro1, micro2, time1 = 0, time2;
 151
 152     srcbytes = (srcbits + 7) / 8;
 153     dstbytes = (dstbits + 7) / 8;
 154
 155     if (verify)
 156     {
 157         ConvertPixels(testpixels, 0, srcfmt,
 158                        dstbuf_orig, numtestpixels * dstbytes, dstfmt,
 159                        numtestpixels,
 160                        VERIFY_SIZE / numtestpixels,
 161                        bm);
 162
 163     }
 164
 165     if (bench && benchmem)
 166     {
 167         CurrentTime(&sec1, &micro1);
 168         ConvertPixels(benchmem, 0, srcfmt,
 169                        benchmem, 0, dstfmt,
 170                        bench, 1,
 171                        bm);
 172
 173         CurrentTime(&sec2, &micro2);
 174
 175         time1 = (sec2 - sec1) * 1000000 + (((LONG)micro2) - ((LONG)micro1));
 176     }
 177
 178     HIDD_BM_SetRGBConversionFunction(bm, srcfmt, dstfmt, f);
 179
 180     if (verify)
 181     {
 182         ConvertPixels(testpixels, 0, srcfmt,
 183                        dstbuf_new, numtestpixels * dstbytes, dstfmt,
 184                        numtestpixels,
 185                        VERIFY_SIZE / numtestpixels,
 186                        bm);
 187
 188         if (memcmp(dstbuf_orig, dstbuf_new, (VERIFY_SIZE / numtestpixels) * (numtestpixels * dstbytes)) != 0)
 189         {
 190             int numtest = (VERIFY_SIZE / numtestpixels) * numtestpixels;
 191
 192             bug("  Verify %s to %s (%s to %s) failed!\n",
 193                 srcfmt_string, dstfmt_string,
 194                 pf_to_string[srcfmt], pf_to_string[dstfmt]);
 195
 196             dumpmem((UBYTE *)testpixels, numtestpixels, srcbytes, (STRPTR)"SRC:");
 197             dumpmem((UBYTE *)dstbuf_orig, numtest, dstbytes, (STRPTR)"OLD:");
 198             dumpmem((UBYTE *)dstbuf_new, numtest, dstbytes, (STRPTR)"NEW:");
 199
 200         }
 201
 202     }
 203
 204     if (bench && benchmem)
 205     {
 206         static char sbuf[256];
 207
 208         CurrentTime(&sec1, &micro1);
 209         ConvertPixels(benchmem, 0, srcfmt,
 210                        benchmem, 0, dstfmt,
 211                        bench, 1,
 212                        bm);
 213
 214         CurrentTime(&sec2, &micro2);
 215
 216         time2 = (sec2 - sec1) * 1000000 + (((LONG)micro2) - ((LONG)micro1));
 217
 218         sprintf(sbuf, " Benchmark %s to %s (%s to %s): before %d (%f) after %d (%f) (%d %%)\n",
 219                       srcfmt_string, dstfmt_string,
 220                       pf_to_string[srcfmt], pf_to_string[dstfmt],
 221                       (int)time1, time1 / 1000000.0,
 222                       (int)time2, time2 / 1000000.0,
 223                       (int)(time2 ? time1 * 100 / time2 : 0));
 224         bug("%s", sbuf);
 225     }
 226
 227 }
 228
 229 #define PATCHFUNC(a,b) \
 230     (*func)(FMT_ ## a, FMT_ ## b, a ## _ ## BITS, b ## _ ## BITS, convert_ ## a ## _ ## b, \
 231                 verify, bench, testpixels_ ## a, NUMTESTPIXELS_ ## a, # a, # b, HIDD_BM_OBJ(bitmap));
 232
 233 int main(int argc, char **argv)
 234 {
 235     struct RDArgs *myargs;
 236     BOOL           verify = FALSE;
 237     ULONG          bench = 0;
 238     DOFUNC         func = installfunc;
 239     int            i;
 240     struct BitMap  *bitmap;
 241
 242     HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap);
 243     if (!HiddBitMapAttrBase) {
 244         printf("Failed to obtain IID_Hidd_BitMap\n");
 245
 246         return RETURN_FAIL;
 247     }
 248
 249     if ((myargs = ReadArgs((STRPTR)ARG_TEMPLATE, args, NULL)))
 250     {
 251         if (args[ARG_VERIFY]) verify = TRUE;
 252         if (args[ARG_BENCH]) bench = *(IPTR *)args[ARG_BENCH];
 253         if (args[ARG_NOISY]) noisy = TRUE;
 254
 255         FreeArgs(myargs);
 256     }
 257     else
 258     {
 259         PrintFault(IoErr(), (STRPTR)argv[0]);
 260         OOP_ReleaseAttrBase(IID_Hidd_BitMap);
 261         return RETURN_FAIL;
 262     }
 263
 264     if (bench)
 265     {
 266         benchmem = malloc(bench * 4);
 267         if (!benchmem)
 268         {
 269             PrintFault(ERROR_NO_FREE_STORE, (STRPTR)argv[0]);
 270             OOP_ReleaseAttrBase(IID_Hidd_BitMap);
 271             return RETURN_FAIL;
 272         }
 273     }
 274
 275     /* We need a placeholder bitmap object in order to talk to bitmap class */
 276     bitmap = AllocBitMap(1, 1, 16, 0, NULL);
 277     if (!bitmap) {
 278         PrintFault(ERROR_NO_FREE_STORE, (STRPTR)argv[0]);
 279         OOP_ReleaseAttrBase(IID_Hidd_BitMap);
 280         return RETURN_FAIL;
 281     }
 282
 283     #define P(a,b) PATCHFUNC(a,b)
 284
 285     for(i = 0; i < 2; i++)
 286     {
 287         /* ARGB32 to #? */
 288         P(ARGB32,RGB16)   P(ARGB32,BGR16)   P(ARGB32,RGB15)   P(ARGB32,BGR15)
 289         P(ARGB32,BGRA32)  P(ARGB32,RGBA32)  P(ARGB32,ABGR32)  P(ARGB32,RGB24)
 290         P(ARGB32,BGR24)   P(ARGB32,RGB16OE) P(ARGB32,BGR16OE) P(ARGB32,RGB15OE)
 291         P(ARGB32,BGR15OE) P(ARGB32,XRGB32)  P(ARGB32,BGRX32)  P(ARGB32,RGBX32)
 292         P(ARGB32,XBGR32)
 293
 294         /* BGRA32 to #? */
 295         P(BGRA32,RGB16)   P(BGRA32,BGR16)   P(BGRA32,RGB15)   P(BGRA32,BGR15)
 296         P(BGRA32,ARGB32)  P(BGRA32,RGBA32)  P(BGRA32,ABGR32)  P(BGRA32,RGB24)
 297         P(BGRA32,BGR24)   P(BGRA32,RGB16OE) P(BGRA32,BGR16OE) P(BGRA32,RGB15OE)
 298         P(BGRA32,BGR15OE) P(BGRA32,XRGB32)  P(BGRA32,BGRX32)  P(BGRA32,RGBX32)
 299         P(BGRA32,XBGR32)
 300
 301         /* RGBA32 to #? */
 302         P(RGBA32,RGB16)   P(RGBA32,BGR16)   P(RGBA32,RGB15)   P(RGBA32,BGR15)
 303         P(RGBA32,BGRA32)  P(RGBA32,ARGB32)  P(RGBA32,ABGR32)  P(RGBA32,RGB24)
 304         P(RGBA32,BGR24)   P(RGBA32,RGB16OE) P(RGBA32,BGR16OE) P(RGBA32,RGB15OE)
 305         P(RGBA32,BGR15OE) P(RGBA32,XRGB32)  P(RGBA32,BGRX32)  P(RGBA32,RGBX32)
 306         P(RGBA32,XBGR32)
 307
 308         /* ABGR32 to #? */
 309         P(ABGR32,RGB16)   P(ABGR32,BGR16)   P(ABGR32,RGB15)   P(ABGR32,BGR15)
 310         P(ABGR32,BGRA32)  P(ABGR32,ARGB32)  P(ABGR32,RGBA32)  P(ABGR32,RGB24)
 311         P(ABGR32,BGR24)   P(ABGR32,RGB16OE) P(ABGR32,BGR16OE) P(ABGR32,RGB15OE)
 312         P(ABGR32,BGR15OE) P(ABGR32,XRGB32)  P(ABGR32,BGRX32)  P(ABGR32,RGBX32)
 313         P(ABGR32,XBGR32)
 314
 315         /* RGB24 to #? */
 316         P(RGB24,RGB16)    P(RGB24,BGR16)    P(RGB24,RGB15)    P(RGB24,BGR15)
 317         P(RGB24,ARGB32)   P(RGB24,BGRA32)   P(RGB24,RGBA32)   P(RGB24,ABGR32)
 318         P(RGB24,BGR24)    P(RGB24,RGB16OE)  P(RGB24,BGR16OE)  P(RGB24,RGB15OE)
 319         P(RGB24,BGR15OE)  P(RGB24,XRGB32)   P(RGB24,BGRX32)   P(RGB24,RGBX32)
 320         P(RGB24,XBGR32)
 321
 322         /* BGR24 to #? */
 323         P(BGR24,RGB16)    P(BGR24,BGR16)    P(BGR24,RGB15)    P(BGR24,BGR15)
 324         P(BGR24,ARGB32)   P(BGR24,BGRA32)   P(BGR24,RGBA32)   P(BGR24,ABGR32)
 325         P(BGR24,RGB24)    P(BGR24,RGB16OE)  P(BGR24,BGR16OE)  P(BGR24,RGB15OE)
 326         P(BGR24,BGR15OE)  P(BGR24,XRGB32)   P(BGR24,BGRX32)   P(BGR24,RGBX32)
 327         P(BGR24,XBGR32)
 328
 329         /* RGB15 to #? */
 330         P(RGB15,RGB16)    P(RGB15,BGR16)    P(RGB15,BGR15)    P(RGB15,ARGB32)
 331         P(RGB15,BGRA32)   P(RGB15,RGBA32)   P(RGB15,ABGR32)   P(RGB15,RGB24)
 332         P(RGB15,BGR24)    P(RGB15,RGB16OE)  P(RGB15,RGB15OE)  P(RGB15,BGR16OE)
 333         P(RGB15,BGR15OE)  P(RGB15,XRGB32)   P(RGB15,BGRX32)   P(RGB15,RGBX32)
 334         P(RGB15,XBGR32)
 335
 336         /* BGR15 to #? */
 337         P(BGR15,RGB16)    P(BGR15,BGR16)    P(BGR15,RGB15)    P(BGR15,ARGB32)
 338         P(BGR15,BGRA32)   P(BGR15,RGBA32)   P(BGR15,ABGR32)   P(BGR15,RGB24)
 339         P(BGR15,BGR24)    P(BGR15,RGB16OE)  P(BGR15,RGB15OE)  P(BGR15,BGR16OE)
 340         P(BGR15,BGR15OE)  P(BGR15,XRGB32)   P(BGR15,BGRX32)   P(BGR15,RGBX32)
 341         P(BGR15,XBGR32)
 342
 343         /* RGB16 to #? */
 344         P(RGB16,RGB15)    P(RGB16,BGR16)    P(RGB16,BGR15)    P(RGB16,ARGB32)
 345         P(RGB16,BGRA32)   P(RGB16,RGBA32)   P(RGB16,ABGR32)   P(RGB16,RGB24)
 346         P(RGB16,BGR24)    P(RGB16,RGB16OE)  P(RGB16,RGB15OE)  P(RGB16,BGR16OE)
 347         P(RGB16,BGR15OE)  P(RGB16,XRGB32)   P(RGB16,BGRX32)   P(RGB16,RGBX32)
 348         P(RGB16,XBGR32)
 349
 350         /* BGR16 to #? */
 351         P(BGR16,RGB15)    P(BGR16,RGB16)    P(BGR16,BGR15)    P(BGR16,ARGB32)
 352         P(BGR16,BGRA32)   P(BGR16,RGBA32)   P(BGR16,ABGR32)   P(BGR16,RGB24)
 353         P(BGR16,BGR24)    P(BGR16,RGB16OE)  P(BGR16,RGB15OE)  P(BGR16,BGR16OE)
 354         P(BGR16,BGR15OE)  P(BGR16,XRGB32)   P(BGR16,BGRX32)   P(BGR16,RGBX32)
 355         P(BGR16,XBGR32)
 356
 357         /* RGB16OE to #? */
 358         P(RGB16OE,RGB16)   P(RGB16OE,RGB15)  P(RGB16OE,BGR16)   P(RGB16OE,BGR15)
 359         P(RGB16OE,ARGB32)  P(RGB16OE,BGRA32) P(RGB16OE,RGBA32)  P(RGB16OE,ABGR32)
 360         P(RGB16OE,RGB24)   P(RGB16OE,BGR24)  P(RGB16OE,RGB15OE) P(RGB16OE,BGR16OE)
 361         P(RGB16OE,BGR15OE) P(RGB16OE,XRGB32) P(RGB16OE,BGRX32)  P(RGB16OE,RGBX32)
 362         P(RGB16OE,XBGR32)
 363
 364         /* BGR16OE to #? */
 365         P(BGR16OE,RGB16)   P(BGR16OE,RGB15)  P(BGR16OE,BGR16)   P(BGR16OE,BGR15)
 366         P(BGR16OE,ARGB32)  P(BGR16OE,BGRA32) P(BGR16OE,RGBA32)  P(BGR16OE,ABGR32)
 367         P(BGR16OE,RGB24)   P(BGR16OE,BGR24)  P(BGR16OE,RGB15OE) P(BGR16OE,RGB16OE)
 368         P(BGR16OE,BGR15OE) P(BGR16OE,XRGB32) P(BGR16OE,BGRX32)  P(BGR16OE,RGBX32)
 369         P(BGR16OE,XBGR32)
 370
 371         /* RGB15OE to #? */
 372         P(RGB15OE,RGB16)   P(RGB15OE,RGB15)  P(RGB15OE,BGR16)   P(RGB15OE,BGR15)
 373         P(RGB15OE,ARGB32)  P(RGB15OE,BGRA32) P(RGB15OE,RGBA32)  P(RGB15OE,ABGR32)
 374         P(RGB15OE,RGB24)   P(RGB15OE,BGR24)  P(RGB15OE,RGB16OE) P(RGB15OE,BGR16OE)
 375         P(RGB15OE,BGR15OE) P(RGB15OE,XRGB32) P(RGB15OE,BGRX32)  P(RGB15OE,RGBX32)
 376         P(RGB15OE,XBGR32)
 377
 378         /* BGR15OE to #? */
 379         P(BGR15OE,RGB16)   P(BGR15OE,RGB15)  P(BGR15OE,BGR16)   P(BGR15OE,BGR15)
 380         P(BGR15OE,ARGB32)  P(BGR15OE,BGRA32) P(BGR15OE,RGBA32)  P(BGR15OE,ABGR32)
 381         P(BGR15OE,RGB24)   P(BGR15OE,BGR24)  P(BGR15OE,RGB16OE) P(BGR15OE,BGR16OE)
 382         P(BGR15OE,RGB15OE) P(BGR15OE,XRGB32) P(BGR15OE,BGRX32)  P(BGR15OE,RGBX32)
 383         P(BGR15OE,XBGR32)
 384
 385         /* XRGB32 to #? */
 386         P(XRGB32,RGB16)   P(XRGB32,BGR16)   P(XRGB32,RGB15)   P(XRGB32,BGR15)
 387         P(XRGB32,ARGB32)  P(XRGB32,BGRA32)  P(XRGB32,RGBA32)  P(XRGB32,ABGR32)
 388         P(XRGB32,RGB24)   P(XRGB32,BGR24)   P(XRGB32,RGB16OE) P(XRGB32,BGR16OE)
 389         P(XRGB32,RGB15OE) P(XRGB32,BGR15OE) P(XRGB32,BGRX32)  P(XRGB32,RGBX32)
 390         P(XRGB32,XBGR32)
 391
 392         /* BGRX32 to #? */
 393         P(BGRX32,RGB16)   P(BGRX32,BGR16)   P(BGRX32,RGB15)   P(BGRX32,BGR15)
 394         P(BGRX32,ARGB32)  P(BGRX32,BGRA32)  P(BGRX32,RGBA32)  P(BGRX32,ABGR32)
 395         P(BGRX32,RGB24)   P(BGRX32,BGR24)   P(BGRX32,RGB16OE) P(BGRX32,BGR16OE)
 396         P(BGRX32,RGB15OE) P(BGRX32,BGR15OE) P(BGRX32,XRGB32)  P(BGRX32,RGBX32)
 397         P(BGRX32,XBGR32)
 398
 399         /* RGBX32 to #? */
 400         P(RGBX32,RGB16)   P(RGBX32,BGR16)   P(RGBX32,RGB15)   P(RGBX32,BGR15)
 401         P(RGBX32,BGRA32)  P(RGBX32,ARGB32)  P(RGBX32,ABGR32)  P(RGBX32,RGBA32)
 402         P(RGBX32,RGB24)   P(RGBX32,BGR24)   P(RGBX32,RGB16OE) P(RGBX32,BGR16OE)
 403         P(RGBX32,RGB15OE) P(RGBX32,BGR15OE) P(RGBX32,XRGB32)  P(RGBX32,BGRX32)
 404         P(RGBX32,XBGR32)
 405
 406         /* XBGR32 to #? */
 407         P(XBGR32,RGB16)   P(XBGR32,BGR16)   P(XBGR32,RGB15)   P(XBGR32,BGR15)
 408         P(XBGR32,BGRA32)  P(XBGR32,ARGB32)  P(XBGR32,RGBA32)  P(XBGR32,ABGR32)
 409         P(XBGR32,RGB24)   P(XBGR32,BGR24)   P(XBGR32,RGB16OE) P(XBGR32,BGR16OE)
 410         P(XBGR32,RGB15OE) P(XBGR32,BGR15OE) P(XBGR32,XRGB32)  P(XBGR32,BGRX32)
 411         P(XBGR32,RGBX32)
 412
 413         if (i == 0)
 414         {
 415             Wait(SIGBREAKF_CTRL_C);
 416
 417             func = uninstallfunc;
 418         }
 419
 420     } /* for(int i= 0; i < 2; i++) */
 421
 422     #undef P
 423
 424     FreeBitMap(bitmap);
 425     OOP_ReleaseAttrBase(IID_Hidd_BitMap);
 426
 427     return RETURN_OK;
 428 }