test/patchrgbconv_rgbswap.h

   1 #define SWAP32CODE                                  \
   2     ULONG *src = (ULONG *)srcPixels;                \
   3     ULONG *dst = (ULONG *)dstPixels;                \
   4     ULONG x, y;                                     \
   5                                                     \
   6     for(y = 0; y < height; y++)                     \
   7     {                                               \
   8         for(x = 0; x < width; x++)                  \
   9         {                                           \
  10             ULONG s = src[x];                       \
  11                                                     \
  12             dst[x] = AROS_SWAP_BYTES_LONG(s);       \
  13         }                                           \
  14         src = (ULONG *)(((UBYTE *)src) + srcMod);   \
  15         dst = (ULONG *)(((UBYTE *)dst) + dstMod);   \
  16     }                                               \
  17                                                     \
  18     return 1;
  19
  20 #define SWAP16CODE                                  \
  21     UWORD *src = (UWORD *)srcPixels;                \
  22     UWORD *dst = (UWORD *)dstPixels;                \
  23     ULONG x, y;                                     \
  24                                                     \
  25     for(y = 0; y < height; y++)                     \
  26     {                                               \
  27         for(x = 0; x < width; x++)                  \
  28         {                                           \
  29             UWORD s = src[x];                       \
  30                                                     \
  31             dst[x] = AROS_SWAP_BYTES_WORD(s);       \
  32         }                                           \
  33         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
  34         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
  35     }                                               \
  36                                                     \
  37     return 1;
  38
  39 #define SWAP2432CODE                                \
  40     UBYTE *src = (UBYTE *)srcPixels;                \
  41     ULONG *dst = (ULONG *)dstPixels;                \
  42     ULONG x, y;                                     \
  43                                                     \
  44     for(y = 0; y < height; y++)                     \
  45     {                                               \
  46         for(x = 0; x < width; x++)                  \
  47         {                                           \
  48             ULONG s = GET24_INV;                    \
  49                                                     \
  50             dst[x] = s;                             \
  51         }                                           \
  52         src = (UBYTE *)(((UBYTE *)src) + srcMod);   \
  53         dst = (ULONG *)(((UBYTE *)dst) + dstMod);   \
  54     }                                               \
  55                                                     \
  56     return 1;
  57
  58 #define SWAP2424CODE                                \
  59     UBYTE *src = (UBYTE *)srcPixels;                \
  60     UBYTE *dst = (UBYTE *)dstPixels;                \
  61     ULONG x, y;                                     \
  62                                                     \
  63     for(y = 0; y < height; y++)                     \
  64     {                                               \
  65         for(x = 0; x < width; x++)                  \
  66         {                                           \
  67             dst[x * 3]     = src[x * 3 + 2];        \
  68             dst[x * 3 + 1] = src[x * 3 + 1];        \
  69             dst[x * 3 + 2] = src[x * 3];            \
  70         }                                           \
  71         src = (UBYTE *)(((UBYTE *)src) + srcMod);   \
  72         dst = (UBYTE *)(((UBYTE *)dst) + dstMod);   \
  73     }                                               \
  74                                                     \
  75     return 1;
  76
  77 #define SWAP1515CODE                                \
  78     UWORD *src = (UWORD *)srcPixels;                \
  79     UWORD *dst = (UWORD *)dstPixels;                \
  80     ULONG x, y;                                     \
  81                                                     \
  82     for(y = 0; y < height; y++)                     \
  83     {                                               \
  84         for(x = 0; x < width; x++)                  \
  85         {                                           \
  86             UWORD s = src[x];                       \
  87                                                     \
  88             dst[x] = ((s & RGB15_RMASK) >> 10) |    \
  89                      ((s & RGB15_GMASK)) |          \
  90                      ((s & RGB15_BMASK) << 10);     \
  91         }                                           \
  92         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
  93         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
  94     }                                               \
  95                                                     \
  96     return 1;
  97
  98 #define SWAP15OE15CODE                              \
  99     UWORD *src = (UWORD *)srcPixels;                \
 100     UWORD *dst = (UWORD *)dstPixels;                \
 101     ULONG x, y;                                     \
 102                                                     \
 103     for(y = 0; y < height; y++)                     \
 104     {                                               \
 105         for(x = 0; x < width; x++)                  \
 106         {                                           \
 107             UWORD s = INV16(src[x]);                \
 108                                                     \
 109             dst[x] = ((s & RGB15_RMASK) >> 10) |    \
 110                      ((s & RGB15_GMASK)) |          \
 111                      ((s & RGB15_BMASK) << 10);     \
 112         }                                           \
 113         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 114         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 115     }                                               \
 116                                                     \
 117     return 1;
 118
 119 #define SWAP1515OECODE                              \
 120     UWORD *src = (UWORD *)srcPixels;                \
 121     UWORD *dst = (UWORD *)dstPixels;                \
 122     ULONG x, y;                                     \
 123                                                     \
 124     for(y = 0; y < height; y++)                     \
 125     {                                               \
 126         for(x = 0; x < width; x++)                  \
 127         {                                           \
 128             UWORD s = src[x];                       \
 129                                                     \
 130             s = ((s & RGB15_RMASK) >> 10) |         \
 131                      ((s & RGB15_GMASK)) |          \
 132                      ((s & RGB15_BMASK) << 10);     \
 133             dst[x] = INV16(s);                      \
 134         }                                           \
 135         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 136         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 137     }                                               \
 138                                                     \
 139     return 1;
 140
 141 #define SWAP15OE15OECODE                            \
 142     UWORD *src = (UWORD *)srcPixels;                \
 143     UWORD *dst = (UWORD *)dstPixels;                \
 144     ULONG x, y;                                     \
 145                                                     \
 146     for(y = 0; y < height; y++)                     \
 147     {                                               \
 148         for(x = 0; x < width; x++)                  \
 149         {                                           \
 150             UWORD s = INV16(src[x]);                \
 151                                                     \
 152             s = ((s & RGB15_RMASK) >> 10) |         \
 153                      ((s & RGB15_GMASK)) |          \
 154                      ((s & RGB15_BMASK) << 10);     \
 155             dst[x] = INV16(s);                      \
 156         }                                           \
 157         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 158         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 159     }                                               \
 160                                                     \
 161     return 1;
 162
 163 #define SWAP1616CODE                                \
 164     UWORD *src = (UWORD *)srcPixels;                \
 165     UWORD *dst = (UWORD *)dstPixels;                \
 166     ULONG x, y;                                     \
 167                                                     \
 168     for(y = 0; y < height; y++)                     \
 169     {                                               \
 170         for(x = 0; x < width; x++)                  \
 171         {                                           \
 172             UWORD s = src[x];                       \
 173                                                     \
 174             dst[x] = ((s & RGB16_RMASK) >> 11) |    \
 175                      ((s & RGB16_GMASK)) |          \
 176                      ((s & RGB16_BMASK) << 11);     \
 177         }                                           \
 178         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 179         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 180     }                                               \
 181                                                     \
 182     return 1;
 183
 184 #define SWAP16OE16CODE                                      \
 185     UWORD *src = (UWORD *)srcPixels;                \
 186     UWORD *dst = (UWORD *)dstPixels;                \
 187     ULONG x, y;                                     \
 188                                                     \
 189     for(y = 0; y < height; y++)                     \
 190     {                                               \
 191         for(x = 0; x < width; x++)                  \
 192         {                                           \
 193             UWORD s = INV16(src[x]);                \
 194                                                     \
 195             dst[x] = ((s & RGB16_RMASK) >> 11) |    \
 196                      ((s & RGB16_GMASK)) |          \
 197                      ((s & RGB16_BMASK) << 11);     \
 198         }                                           \
 199         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 200         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 201     }                                               \
 202                                                     \
 203     return 1;
 204
 205 #define SWAP1616OECODE                              \
 206     UWORD *src = (UWORD *)srcPixels;                \
 207     UWORD *dst = (UWORD *)dstPixels;                \
 208     ULONG x, y;                                     \
 209                                                     \
 210     for(y = 0; y < height; y++)                     \
 211     {                                               \
 212         for(x = 0; x < width; x++)                  \
 213         {                                           \
 214             UWORD s = src[x];                       \
 215                                                     \
 216             s = ((s & RGB16_RMASK) >> 11) |         \
 217                 ((s & RGB16_GMASK)) |               \
 218                 ((s & RGB16_BMASK) << 11);          \
 219             dst[x] = INV16(s);                      \
 220         }                                           \
 221         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 222         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 223     }                                               \
 224                                                     \
 225     return 1;
 226
 227 #define SWAP16OE16OECODE                            \
 228     UWORD *src = (UWORD *)srcPixels;                \
 229     UWORD *dst = (UWORD *)dstPixels;                \
 230     ULONG x, y;                                     \
 231                                                     \
 232     for(y = 0; y < height; y++)                     \
 233     {                                               \
 234         for(x = 0; x < width; x++)                  \
 235         {                                           \
 236             UWORD s = INV16(src[x]);                \
 237                                                     \
 238             s = ((s & RGB16_RMASK) >> 11) |         \
 239                 ((s & RGB16_GMASK)) |               \
 240                 ((s & RGB16_BMASK) << 11);          \
 241             dst[x] = INV16(s);                      \
 242         }                                           \
 243         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 244         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 245     }                                               \
 246                                                     \
 247     return 1;
 248
 249 #define SWAP1516CODE                                \
 250     UWORD *src = (UWORD *)srcPixels;                \
 251     UWORD *dst = (UWORD *)dstPixels;                \
 252     ULONG x, y;                                     \
 253                                                     \
 254     for(y = 0; y < height; y++)                     \
 255     {                                               \
 256         for(x = 0; x < width; x++)                  \
 257         {                                           \
 258             UWORD s = src[x];                       \
 259                                                     \
 260             dst[x] = ((s & RGB15_RMASK) >> 10) |    \
 261                      ((s & RGB15_GMASK) << 1) |     \
 262                      ((s & RGB15_BMASK) << 11);     \
 263         }                                           \
 264         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 265         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 266     }                                               \
 267                                                     \
 268     return 1;
 269
 270 #define SWAP15OE16CODE                              \
 271     UWORD *src = (UWORD *)srcPixels;                \
 272     UWORD *dst = (UWORD *)dstPixels;                \
 273     ULONG x, y;                                     \
 274                                                     \
 275     for(y = 0; y < height; y++)                     \
 276     {                                               \
 277         for(x = 0; x < width; x++)                  \
 278         {                                           \
 279             UWORD s = INV16(src[x]);                \
 280                                                     \
 281             dst[x] = ((s & RGB15_RMASK) >> 10) |    \
 282                      ((s & RGB15_GMASK) << 1) |     \
 283                      ((s & RGB15_BMASK) << 11);     \
 284         }                                           \
 285         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 286         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 287     }                                               \
 288                                                     \
 289     return 1;
 290
 291 #define SWAP1516OECODE                              \
 292     UWORD *src = (UWORD *)srcPixels;                \
 293     UWORD *dst = (UWORD *)dstPixels;                \
 294     ULONG x, y;                                     \
 295                                                     \
 296     for(y = 0; y < height; y++)                     \
 297     {                                               \
 298         for(x = 0; x < width; x++)                  \
 299         {                                           \
 300             UWORD s = src[x];                       \
 301                                                     \
 302             s = ((s & RGB15_RMASK) >> 10) |         \
 303                 ((s & RGB15_GMASK) << 1) |          \
 304                 ((s & RGB15_BMASK) << 11);          \
 305             dst[x] = INV16(s);                      \
 306         }                                           \
 307         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 308         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 309     }                                               \
 310                                                     \
 311     return 1;
 312
 313 #define SWAP15OE16OECODE                            \
 314     UWORD *src = (UWORD *)srcPixels;                \
 315     UWORD *dst = (UWORD *)dstPixels;                \
 316     ULONG x, y;                                     \
 317                                                     \
 318     for(y = 0; y < height; y++)                     \
 319     {                                               \
 320         for(x = 0; x < width; x++)                  \
 321         {                                           \
 322             UWORD s = INV16(src[x]);                \
 323                                                     \
 324             s = ((s & RGB15_RMASK) >> 10) |         \
 325                 ((s & RGB15_GMASK) << 1) |          \
 326                 ((s & RGB15_BMASK) << 11);          \
 327             dst[x] = INV16(s);                      \
 328         }                                           \
 329         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 330         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 331     }                                               \
 332                                                     \
 333     return 1;
 334
 335 #define SWAP1615CODE                                \
 336     UWORD *src = (UWORD *)srcPixels;                \
 337     UWORD *dst = (UWORD *)dstPixels;                \
 338     ULONG x, y;                                     \
 339                                                     \
 340     for(y = 0; y < height; y++)                     \
 341     {                                               \
 342         for(x = 0; x < width; x++)                  \
 343         {                                           \
 344             UWORD s = src[x];                       \
 345                                                     \
 346             dst[x] = ((s >> 11) & RGB15_BMASK) |    \
 347                      ((s >> 1) & RGB15_GMASK) |     \
 348                      ((s << 10) & RGB15_RMASK);     \
 349         }                                           \
 350         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 351         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 352     }                                               \
 353                                                     \
 354     return 1;
 355
 356 #define SWAP16OE15CODE                              \
 357     UWORD *src = (UWORD *)srcPixels;                \
 358     UWORD *dst = (UWORD *)dstPixels;                \
 359     ULONG x, y;                                     \
 360                                                     \
 361     for(y = 0; y < height; y++)                     \
 362     {                                               \
 363         for(x = 0; x < width; x++)                  \
 364         {                                           \
 365             UWORD s = INV16(src[x]);                \
 366                                                     \
 367             dst[x] = ((s >> 11) & RGB15_BMASK) |    \
 368                      ((s >> 1) & RGB15_GMASK) |     \
 369                      ((s << 10) & RGB15_RMASK);     \
 370         }                                           \
 371         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 372         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 373     }                                               \
 374                                                     \
 375     return 1;
 376
 377 #define SWAP1615OECODE                              \
 378     UWORD *src = (UWORD *)srcPixels;                \
 379     UWORD *dst = (UWORD *)dstPixels;                \
 380     ULONG x, y;                                     \
 381                                                     \
 382     for(y = 0; y < height; y++)                     \
 383     {                                               \
 384         for(x = 0; x < width; x++)                  \
 385         {                                           \
 386             UWORD s = src[x];                       \
 387                                                     \
 388             s = ((s >> 11) & RGB15_BMASK) |         \
 389                 ((s >> 1) & RGB15_GMASK) |          \
 390                 ((s << 10) & RGB15_RMASK);          \
 391             dst[x] = INV16(s);                      \
 392         }                                           \
 393         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 394         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 395     }                                               \
 396                                                     \
 397     return 1;
 398
 399
 400 #define SWAP16OE15OECODE                            \
 401     UWORD *src = (UWORD *)srcPixels;                \
 402     UWORD *dst = (UWORD *)dstPixels;                \
 403     ULONG x, y;                                     \
 404                                                     \
 405     for(y = 0; y < height; y++)                     \
 406     {                                               \
 407         for(x = 0; x < width; x++)                  \
 408         {                                           \
 409             UWORD s = INV16(src[x]);                \
 410                                                     \
 411             s = ((s >> 11) & RGB15_BMASK) |         \
 412                 ((s >> 1) & RGB15_GMASK) |          \
 413                 ((s << 10) & RGB15_RMASK);          \
 414             dst[x] = INV16(s);                      \
 415         }                                           \
 416         src = (UWORD *)(((UBYTE *)src) + srcMod);   \
 417         dst = (UWORD *)(((UBYTE *)dst) + dstMod);   \
 418     }                                               \
 419                                                     \
 420     return 1;
 421