rom/hidds/graphics/colorconv/rgbconv_bgra32.h

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