rom/hidds/graphics/colorconv/rgbconv_xbgr32.h

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