test/patchrgbconv_rgba32.h

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