rom/hidds/graphics/colorconv/rgbconv_rgbx32.h

   1 CONVERTFUNC(RGBX32,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
  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(RGBX32,BGR16)
  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(RGBX32,RGB15)
  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(RGBX32,BGR15)
  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(RGBX32,RGBA32)
 102 {
 103     CONVERTFUNC_INIT
 104
 105     ULONG *src = (ULONG *)srcPixels;
 106     ULONG *dst = (ULONG *)dstPixels;
 107     ULONG x, y;
 108
 109     for(y = 0; y < height; y++)
 110     {
 111         for(x = 0; x < width; x++)
 112         {
 113             ULONG s = src[x];
 114
 115             dst[x] = s & 0xFFFFFF00;
 116         }
 117         src = (ULONG *)(((UBYTE *)src) + srcMod);
 118         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 119     }
 120
 121     return 1;
 122
 123     CONVERTFUNC_EXIT
 124 }
 125
 126
 127 CONVERTFUNC(RGBX32,ABGR32)
 128 {
 129     CONVERTFUNC_INIT
 130
 131     ULONG *src = (ULONG *)srcPixels;
 132     ULONG *dst = (ULONG *)dstPixels;
 133     ULONG x, y;
 134
 135     for(y = 0; y < height; y++)
 136     {
 137         for(x = 0; x < width; x++)
 138         {
 139             ULONG s = src[x];
 140
 141             dst[x] = SHUFFLE24(s, RGBA32, ABGR32);
 142         }
 143         src = (ULONG *)(((UBYTE *)src) + srcMod);
 144         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 145     }
 146
 147     return 1;
 148
 149     CONVERTFUNC_EXIT
 150 }
 151
 152 CONVERTFUNC(RGBX32,ARGB32)
 153 {
 154     CONVERTFUNC_INIT
 155
 156     ULONG *src = (ULONG *)srcPixels;
 157     ULONG *dst = (ULONG *)dstPixels;
 158     ULONG x, y;
 159
 160     for(y = 0; y < height; y++)
 161     {
 162         for(x = 0; x < width; x++)
 163         {
 164             ULONG s = src[x];
 165
 166             dst[x] = SHUFFLE24(s, RGBA32, ARGB32);
 167         }
 168         src = (ULONG *)(((UBYTE *)src) + srcMod);
 169         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 170     }
 171
 172     return 1;
 173
 174     CONVERTFUNC_EXIT
 175 }
 176
 177
 178 CONVERTFUNC(RGBX32,BGRA32)
 179 {
 180     CONVERTFUNC_INIT
 181
 182     ULONG *src = (ULONG *)srcPixels;
 183     ULONG *dst = (ULONG *)dstPixels;
 184     ULONG x, y;
 185
 186     for(y = 0; y < height; y++)
 187     {
 188         for(x = 0; x < width; x++)
 189         {
 190             ULONG s = src[x];
 191
 192             dst[x] = SHUFFLE24(s, RGBA32, BGRA32);
 193         }
 194         src = (ULONG *)(((UBYTE *)src) + srcMod);
 195         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 196     }
 197
 198     return 1;
 199
 200     CONVERTFUNC_EXIT
 201 }
 202
 203 CONVERTFUNC(RGBX32,RGB24)
 204 {
 205     CONVERTFUNC_INIT
 206
 207     ULONG *src = (ULONG *)srcPixels;
 208     UBYTE *dst = (UBYTE *)dstPixels;
 209     ULONG x, y;
 210
 211     for(y = 0; y < height; y++)
 212     {
 213         for(x = 0; x < width; x++)
 214         {
 215             ULONG s = src[x];
 216
 217             PUT24(dst, COMP8(s, 0), COMP8(s, 1), COMP8(s, 2))
 218         }
 219         src = (ULONG *)(((UBYTE *)src) + srcMod);
 220         dst = (UBYTE *)(((UBYTE *)dst) + dstMod);
 221     }
 222
 223     return 1;
 224
 225     CONVERTFUNC_EXIT
 226 }
 227
 228 CONVERTFUNC(RGBX32,BGR24)
 229 {
 230     CONVERTFUNC_INIT
 231
 232     ULONG *src = (ULONG *)srcPixels;
 233     UBYTE *dst = (UBYTE *)dstPixels;
 234     ULONG x, y;
 235
 236     for(y = 0; y < height; y++)
 237     {
 238         for(x = 0; x < width; x++)
 239         {
 240             ULONG s = src[x];
 241
 242             PUT24(dst, COMP8(s, 2), COMP8(s, 1), COMP8(s, 0))
 243         }
 244         src = (ULONG *)(((UBYTE *)src) + srcMod);
 245         dst = (UBYTE *)(((UBYTE *)dst) + dstMod);
 246     }
 247
 248     return 1;
 249
 250     CONVERTFUNC_EXIT
 251 }
 252
 253 CONVERTFUNC(RGBX32,RGB16OE)
 254 {
 255     CONVERTFUNC_INIT
 256
 257     ULONG *src = (ULONG *)srcPixels;
 258     UWORD *dst = (UWORD *)dstPixels;
 259     ULONG x, y;
 260
 261     for(y = 0; y < height; y++)
 262     {
 263         for(x = 0; x < width; x++)
 264         {
 265             ULONG s = src[x];
 266
 267             s = DOWNSHIFT16(s, RGBA32, RGB16);
 268             dst[x] = INV16(s);
 269         }
 270         src = (ULONG *)(((UBYTE *)src) + srcMod);
 271         dst = (UWORD *)(((UBYTE *)dst) + dstMod);
 272     }
 273
 274     return 1;
 275
 276     CONVERTFUNC_EXIT
 277 }
 278
 279 CONVERTFUNC(RGBX32,BGR16OE)
 280 {
 281     CONVERTFUNC_INIT
 282
 283     ULONG *src = (ULONG *)srcPixels;
 284     UWORD *dst = (UWORD *)dstPixels;
 285     ULONG x, y;
 286
 287     for(y = 0; y < height; y++)
 288     {
 289         for(x = 0; x < width; x++)
 290         {
 291             ULONG s = src[x];
 292
 293             s = DOWNSHIFT16(s, RGBA32, BGR16);
 294             dst[x] = INV16(s);
 295         }
 296         src = (ULONG *)(((UBYTE *)src) + srcMod);
 297         dst = (UWORD *)(((UBYTE *)dst) + dstMod);
 298     }
 299
 300     return 1;
 301
 302     CONVERTFUNC_EXIT
 303 }
 304
 305 CONVERTFUNC(RGBX32,RGB15OE)
 306 {
 307     CONVERTFUNC_INIT
 308
 309     ULONG *src = (ULONG *)srcPixels;
 310     UWORD *dst = (UWORD *)dstPixels;
 311     ULONG x, y;
 312
 313     for(y = 0; y < height; y++)
 314     {
 315         for(x = 0; x < width; x++)
 316         {
 317             ULONG s = src[x];
 318
 319             s = DOWNSHIFT16(s, RGBA32, RGB15);
 320             dst[x] = INV16(s);
 321         }
 322         src = (ULONG *)(((UBYTE *)src) + srcMod);
 323         dst = (UWORD *)(((UBYTE *)dst) + dstMod);
 324     }
 325
 326     return 1;
 327
 328     CONVERTFUNC_EXIT
 329 }
 330
 331 CONVERTFUNC(RGBX32,BGR15OE)
 332 {
 333     CONVERTFUNC_INIT
 334
 335     ULONG *src = (ULONG *)srcPixels;
 336     UWORD *dst = (UWORD *)dstPixels;
 337     ULONG x, y;
 338
 339     for(y = 0; y < height; y++)
 340     {
 341         for(x = 0; x < width; x++)
 342         {
 343             ULONG s = src[x];
 344
 345             s = DOWNSHIFT16(s, RGBA32, BGR15);
 346             dst[x] = INV16(s);
 347         }
 348         src = (ULONG *)(((UBYTE *)src) + srcMod);
 349         dst = (UWORD *)(((UBYTE *)dst) + dstMod);
 350     }
 351
 352     return 1;
 353
 354     CONVERTFUNC_EXIT
 355 }
 356
 357 CONVERTFUNC(RGBX32,BGRX32)
 358 {
 359     CONVERTFUNC_INIT
 360
 361     ULONG *src = (ULONG *)srcPixels;
 362     ULONG *dst = (ULONG *)dstPixels;
 363     ULONG x, y;
 364
 365     for(y = 0; y < height; y++)
 366     {
 367         for(x = 0; x < width; x++)
 368         {
 369             ULONG s = src[x];
 370
 371             dst[x] = SHUFFLE24(s, RGBA32, BGRA32);
 372         }
 373         src = (ULONG *)(((UBYTE *)src) + srcMod);
 374         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 375     }
 376
 377     return 1;
 378
 379     CONVERTFUNC_EXIT
 380 }
 381
 382 CONVERTFUNC(RGBX32,XBGR32)
 383 {
 384     CONVERTFUNC_INIT
 385
 386     SWAP32CODE
 387
 388     CONVERTFUNC_EXIT
 389 }
 390
 391
 392 CONVERTFUNC(RGBX32,XRGB32)
 393 {
 394     CONVERTFUNC_INIT
 395
 396     ULONG *src = (ULONG *)srcPixels;
 397     ULONG *dst = (ULONG *)dstPixels;
 398     ULONG x, y;
 399
 400     for(y = 0; y < height; y++)
 401     {
 402         for(x = 0; x < width; x++)
 403         {
 404             ULONG s = src[x];
 405
 406             dst[x] = SHUFFLE24(s, RGBA32, ARGB32);
 407         }
 408         src = (ULONG *)(((UBYTE *)src) + srcMod);
 409         dst = (ULONG *)(((UBYTE *)dst) + dstMod);
 410     }
 411
 412     return 1;
 413
 414     CONVERTFUNC_EXIT
 415 }