nanocoat/lib/scritchui/scritchPencilRasterScan.c

   1 /* -*- Mode: C; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // -------------------------------------------------------------------------*/
   9
  10 #include <string.h>
  11
  12 #include "sjme/util.h"
  13 #include "lib/scritchui/scritchui.h"
  14 #include "lib/scritchui/scritchuiPencil.h"
  15 #include "lib/scritchui/scritchuiTypes.h"
  16 #include "lib/scritchui/core/coreRaster.h"
  17 #include "sjme/debug.h"
  18 #include "sjme/fixed.h"
  19
  20 sjme_errorCode sjme_scritchpen_corePrim_rawScanFillInt(
  21         sjme_attrInNotNull sjme_scritchui_pencil g,
  22         sjme_attrOutNotNullBuf(rawLen) void* outRaw,
  23         sjme_attrInPositive sjme_jint outRawOff,
  24         sjme_attrInPositive sjme_jint outRawLen,
  25         sjme_attrInValue sjme_jint rawPixel,
  26         sjme_attrInPositiveNonZero sjme_jint inNumPixels)
  27 {
  28         sjme_jint limit, i;
  29         sjme_jint* p;
  30
  31         if (g == NULL || outRaw == NULL)
  32                 return SJME_ERROR_NULL_ARGUMENTS;
  33
  34         if (outRawOff < 0 || outRawLen < 0 || (outRawOff + outRawLen) < 0 ||
  35                 (inNumPixels < 0))
  36                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  37
  38         /* Determine number of pixels to actually draw. */
  39         limit = inNumPixels * g->bytesPerPixel;
  40
  41         if (limit < 0)
  42                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  43
  44         if (outRawLen < limit)
  45                 limit = outRawLen;
  46
  47         /* Fill in. */
  48         p = SJME_POINTER_OFFSET(outRaw, outRawOff);
  49         for (i = 0; i < limit; i += 4)
  50                 *(p++) = rawPixel;
  51
  52         /* Success! */
  53         return SJME_ERROR_NONE;
  54 }
  55
  56 sjme_errorCode sjme_scritchpen_corePrim_rawScanFillShort(
  57         sjme_attrInNotNull sjme_scritchui_pencil g,
  58         sjme_attrOutNotNullBuf(rawLen) void* outRaw,
  59         sjme_attrInPositive sjme_jint outRawOff,
  60         sjme_attrInPositive sjme_jint outRawLen,
  61         sjme_attrInValue sjme_jint rawPixel,
  62         sjme_attrInPositiveNonZero sjme_jint inNumPixels)
  63 {
  64         sjme_jint limit, i;
  65         sjme_jshort* p;
  66
  67         if (g == NULL || outRaw == NULL)
  68                 return SJME_ERROR_NULL_ARGUMENTS;
  69
  70         if (outRawOff < 0 || outRawLen < 0 || (outRawOff + outRawLen) < 0 ||
  71                 (inNumPixels < 0))
  72                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  73
  74         /* Determine number of pixels to actually draw. */
  75         limit = inNumPixels * g->bytesPerPixel;
  76
  77         if (limit < 0)
  78                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  79
  80         if (outRawLen < limit)
  81                 limit = outRawLen;
  82
  83         /* Fill in. */
  84         p = SJME_POINTER_OFFSET(outRaw, outRawOff);
  85         for (i = 0; i < limit; i += 2)
  86                 *(p++) = rawPixel;
  87
  88         /* Success! */
  89         return SJME_ERROR_NONE;
  90 }
  91
  92 sjme_errorCode sjme_scritchpen_corePrim_rawScanFillByte(
  93         sjme_attrInNotNull sjme_scritchui_pencil g,
  94         sjme_attrOutNotNullBuf(rawLen) void* outRaw,
  95         sjme_attrInPositive sjme_jint outRawOff,
  96         sjme_attrInPositive sjme_jint outRawLen,
  97         sjme_attrInValue sjme_jint rawPixel,
  98         sjme_attrInPositiveNonZero sjme_jint inNumPixels)
  99 {
 100         sjme_jint limit, i;
 101         sjme_jbyte* p;
 102
 103         if (g == NULL || outRaw == NULL)
 104                 return SJME_ERROR_NULL_ARGUMENTS;
 105
 106         if (outRawOff < 0 || outRawLen < 0 || (outRawOff + outRawLen) < 0 ||
 107                 (inNumPixels < 0))
 108                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 109
 110         /* Determine number of pixels to actually draw. */
 111         limit = inNumPixels * g->bytesPerPixel;
 112
 113         if (limit < 0)
 114                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 115
 116         if (outRawLen < limit)
 117                 limit = outRawLen;
 118
 119         /* Fill in. */
 120         p = SJME_POINTER_OFFSET(outRaw, outRawOff);
 121         for (i = 0; i < limit; i += 1)
 122                 *(p++) = rawPixel;
 123
 124         /* Success! */
 125         return SJME_ERROR_NONE;
 126 }
 127
 128 sjme_errorCode sjme_scritchpen_corePrim_rawScanGetNoDest(
 129         sjme_attrInNotNull sjme_scritchui_pencil g,
 130         sjme_attrInPositive sjme_jint x,
 131         sjme_attrInPositive sjme_jint y,
 132         sjme_attrOutNotNullBuf(inLen) void* outData,
 133         sjme_attrInPositiveNonZero sjme_jint inDataLen,
 134         sjme_attrInPositiveNonZero sjme_jint inNumPixels)
 135 {
 136         if (g == NULL || outData == NULL)
 137                 return SJME_ERROR_NULL_ARGUMENTS;
 138
 139         if (inDataLen < 0 || inNumPixels < 0)
 140                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 141
 142         /* Just set everything to the first default value. */
 143         memset(outData, 0, inDataLen);
 144
 145         /* Do nothing, there is no reading function. */
 146         return SJME_ERROR_NONE;
 147 }
 148
 149 sjme_errorCode sjme_scritchpen_coreUtil_blendRGBInto(
 150         sjme_attrInNotNull sjme_scritchui_pencil g,
 151         sjme_attrInValue sjme_jboolean destAlpha,
 152         sjme_attrInValue sjme_jboolean srcAlpha,
 153         sjme_attrInValue sjme_jboolean mulAlpha,
 154         sjme_attrInRange(0, 255) sjme_jint mulAlphaValue,
 155         sjme_attrInNotNullBuf(numPixels) sjme_jint* dest,
 156         sjme_attrInNotNullBuf(numPixels) const sjme_jint* src,
 157         sjme_attrInPositive sjme_jint numPixels)
 158 {
 159         sjme_jint i;
 160         sjme_fixed sa, sr, sg, sb, da, dr, dg, db, iA, ca, cr, cg, cb, tff;
 161         sjme_juint srcMask, destMask;
 162
 163         if (g == NULL || dest == NULL || src == NULL)
 164                 return SJME_ERROR_NULL_ARGUMENTS;
 165
 166         if (numPixels < 0)
 167                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 168
 169         /* Source and dest mask, if alpha is applicable. */
 170         destMask = (destAlpha ? 0 : UINT32_C(0xFF000000));
 171         srcMask = (srcAlpha ? 0 : UINT32_C(0xFF000000));
 172
 173         /* Blend each pixel individually. */
 174         /* R(dest) = (R(src) * A(src)) + (R(dest) * (1 - A(src))) */
 175         /* G(dest) = (G(src) * A(src)) + (G(dest) * (1 - A(src))) */
 176         /* B(dest) = (B(src) * A(src)) + (B(dest) * (1 - A(src))) */
 177         /* A(dest) = A(src) + A(dest) - (A(src) * A(dest)) */
 178         tff = sjme_fixed_hi(255);
 179         for (i = 0; i < numPixels; i++)
 180         {
 181                 /* Extract as integers first. */
 182                 da = ((dest[i] | destMask) >> 24) & 0xFF;
 183                 dr = ((dest[i]) >> 16) & 0xFF;
 184                 dg = ((dest[i]) >> 8) & 0xFF;
 185                 db = dest[i] & 0xFF;
 186
 187                 sa = ((src[i] | srcMask) >> 24) & 0xFF;
 188                 sr = ((src[i]) >> 16) & 0xFF;
 189                 sg = ((src[i]) >> 8) & 0xFF;
 190                 sb = src[i] & 0xFF;
 191
 192                 /* Extract components. */
 193                 da = sjme_fixed_fraction(da, 255);
 194                 dr = sjme_fixed_fraction(dr, 255);
 195                 dg = sjme_fixed_fraction(dg, 255);
 196                 db = sjme_fixed_fraction(db, 255);
 197
 198                 sa = sjme_fixed_fraction(sa, 255);
 199                 sr = sjme_fixed_fraction(sr, 255);
 200                 sg = sjme_fixed_fraction(sg, 255);
 201                 sb = sjme_fixed_fraction(sb, 255);
 202
 203                 iA = sjme_fixed_hi(1) - sa;
 204
 205                 /* A(dest) = A(src) + A(dest) - (A(src) * A(dest)) */
 206                 ca = sa + da - sjme_fixed_mul(sa, da);
 207
 208                 /* R(dest) = (R(src) * A(src)) + (R(dest) * (1 - A(src))) */
 209                 cr = sjme_fixed_mul(sr, sa) + sjme_fixed_mul(dr, iA);
 210
 211                 /* G(dest) = (G(src) * A(src)) + (G(dest) * (1 - A(src))) */
 212                 cg = sjme_fixed_mul(sg, sa) + sjme_fixed_mul(dg, iA);
 213
 214                 /* B(dest) = (B(src) * A(src)) + (B(dest) * (1 - A(src))) */
 215                 cb = sjme_fixed_mul(sb, sa) + sjme_fixed_mul(db, iA);
 216
 217                 /* Return the original factor. */
 218                 ca = sjme_fixed_ceil(sjme_fixed_mul(ca, tff));
 219                 cr = sjme_fixed_ceil(sjme_fixed_mul(cr, tff));
 220                 cg = sjme_fixed_ceil(sjme_fixed_mul(cg, tff));
 221                 cb = sjme_fixed_ceil(sjme_fixed_mul(cb, tff));
 222
 223                 /* Recompose. */
 224                 ca = sjme_fixed_int(ca) & 0xFF;
 225                 cr = sjme_fixed_int(cr) & 0xFF;
 226                 cg = sjme_fixed_int(cg) & 0xFF;
 227                 cb = sjme_fixed_int(cb) & 0xFF;
 228                 dest[i] = (ca << 24) | (cr << 16) | (cg << 8) | cb | destMask;
 229         }
 230
 231         /* Success! */
 232         return SJME_ERROR_NONE;
 233 }
 234
 235 sjme_errorCode sjme_scritchpen_coreUtil_rawScanBytes(
 236         sjme_attrInNotNull sjme_scritchui_pencil g,
 237         sjme_attrInPositiveNonZero sjme_jint inPixels,
 238         sjme_attrInPositiveNonZero sjme_jint inBytes,
 239         sjme_attrOutNotNull sjme_attrOutPositiveNonZero sjme_jint* outBytes,
 240         sjme_attrOutNullable sjme_attrOutPositiveNonZero sjme_jint* outLimit)
 241 {
 242         sjme_jint result;
 243
 244         if (g == NULL || outBytes == NULL)
 245                 return SJME_ERROR_NULL_ARGUMENTS;
 246
 247         if (inPixels < 0 || (outLimit != NULL && inBytes < 0))
 248                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 249
 250         /* Depends on the pixel format. */
 251         result = -1;
 252         switch (g->pixelFormat)
 253         {
 254                 case SJME_GFX_PIXEL_FORMAT_INT_ARGB8888:
 255                 case SJME_GFX_PIXEL_FORMAT_INT_RGB888:
 256                 case SJME_GFX_PIXEL_FORMAT_INT_BGRA8888:
 257                 case SJME_GFX_PIXEL_FORMAT_INT_BGRX8888:
 258                 case SJME_GFX_PIXEL_FORMAT_INT_BGR888:
 259                 case SJME_GFX_PIXEL_FORMAT_INT_RGBX8888:
 260                         result = inPixels * 4;
 261                         break;
 262
 263                 case SJME_GFX_PIXEL_FORMAT_BYTE3_RGB888:
 264                 case SJME_GFX_PIXEL_FORMAT_BYTE3_BGR888:
 265                         result = inPixels * 3;
 266                         break;
 267
 268                 case SJME_GFX_PIXEL_FORMAT_SHORT_ARGB4444:
 269                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB565:
 270                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB555:
 271                 case SJME_GFX_PIXEL_FORMAT_SHORT_ABGR1555:
 272                 case SJME_GFX_PIXEL_FORMAT_SHORT_INDEXED65536:
 273                         result = inPixels * 2;
 274                         break;
 275
 276                 case SJME_GFX_PIXEL_FORMAT_BYTE_INDEXED256:
 277                         result = inPixels;
 278                         break;
 279
 280                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED4:
 281                         result = (inPixels >> 1) + (inPixels & 1);
 282                         break;
 283
 284                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED2:
 285                         result = (inPixels >> 2) + ((inPixels >> 1) & 1);
 286                         break;
 287
 288                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED1:
 289                         result = (inPixels >> 3) + ((inPixels >> 2) & 1);
 290                         break;
 291         }
 292
 293         /* Make sure what was calculated did not overflow. */
 294         if (result < 0)
 295                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 296
 297         /* Calculate smaller value? */
 298         if (outLimit != NULL)
 299         {
 300                 /* Use the smaller of the two. */
 301                 if (result < inBytes)
 302                         *outLimit = inBytes;
 303                 else
 304                         *outLimit = result;
 305         }
 306
 307         /* Success! */
 308         *outBytes = result;
 309         return SJME_ERROR_NONE;
 310 }
 311
 312 sjme_errorCode sjme_scritchpen_coreUtil_rawScanToRgb(
 313         sjme_attrInNotNull sjme_scritchui_pencil g,
 314         sjme_attrInNotNullBuf(outRgbLen) sjme_jint* outRgb,
 315         sjme_attrInPositive sjme_jint outRgbOff,
 316         sjme_attrInPositive sjme_jint outRgbLen,
 317         sjme_attrOutNotNullBuf(inRawLen) const void* inRaw,
 318         sjme_attrInPositive sjme_jint inRawOff,
 319         sjme_attrInPositive sjme_jint inRawLen)
 320 {
 321         sjme_errorCode error;
 322         sjme_juint destAlphaMask;
 323         sjme_jint limit, i, t, mulShift, j;
 324         const sjme_jint* si;
 325         const sjme_jshort* ss;
 326         const sjme_jbyte* sb;
 327         sjme_jint* d;
 328         sjme_scritchui_pencilColor color;
 329
 330         if (g == NULL || outRgb == NULL || inRaw == NULL)
 331                 return SJME_ERROR_NULL_ARGUMENTS;
 332
 333         if (outRgbOff < 0 || outRgbLen < 0 || (outRgbOff + outRgbLen) < 0 ||
 334                 inRawOff < 0 || inRawLen < 0 || (inRawOff + inRawLen) < 0)
 335                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 336
 337         /* Destination alpha mask. */
 338         destAlphaMask = (g->hasAlpha ? 0 : 0xFF000000);
 339
 340         /* Determine the type to use for scan reading. */
 341         si = NULL;
 342         ss = NULL;
 343         sb = NULL;
 344         mulShift = 1;
 345         switch (g->pixelFormat)
 346         {
 347                 case SJME_GFX_PIXEL_FORMAT_INT_ARGB8888:
 348                 case SJME_GFX_PIXEL_FORMAT_INT_RGB888:
 349                 case SJME_GFX_PIXEL_FORMAT_INT_BGRA8888:
 350                 case SJME_GFX_PIXEL_FORMAT_INT_BGRX8888:
 351                 case SJME_GFX_PIXEL_FORMAT_INT_BGR888:
 352                 case SJME_GFX_PIXEL_FORMAT_INT_RGBX8888:
 353                         si = SJME_POINTER_OFFSET(inRaw, inRawOff);
 354                         limit = inRawLen / 4;
 355                         break;
 356
 357                 case SJME_GFX_PIXEL_FORMAT_BYTE3_RGB888:
 358                 case SJME_GFX_PIXEL_FORMAT_BYTE3_BGR888:
 359                         sb = SJME_POINTER_OFFSET(inRaw, inRawOff);
 360                         limit = inRawLen / 3;
 361                         mulShift = 3;
 362                         break;
 363
 364                 case SJME_GFX_PIXEL_FORMAT_SHORT_ARGB4444:
 365                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB565:
 366                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB555:
 367                 case SJME_GFX_PIXEL_FORMAT_SHORT_ABGR1555:
 368                 case SJME_GFX_PIXEL_FORMAT_SHORT_INDEXED65536:
 369                         ss = SJME_POINTER_OFFSET(inRaw, inRawOff);
 370                         limit = inRawLen / 2;
 371                         break;
 372
 373                 case SJME_GFX_PIXEL_FORMAT_BYTE_INDEXED256:
 374                         sb = SJME_POINTER_OFFSET(inRaw, inRawOff);
 375                         limit = inRawLen;
 376                         break;
 377
 378                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED4:
 379                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED2:
 380                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED1:
 381                         sjme_todo("Impl?");
 382                         break;
 383
 384                 default:
 385                         return SJME_ERROR_INVALID_ARGUMENT;
 386         }
 387
 388         /* Writing where? */
 389         d = &outRgb[outRgbOff];
 390
 391         /* If the output RGB is smaller than the raw input, limit to it. */
 392         if (outRgbLen < limit)
 393                 limit = outRgbLen;
 394
 395         /* Clear error state. */
 396         error = SJME_ERROR_NONE;
 397
 398         /* Already in the most native format? */
 399         if (g->pixelFormat == SJME_GFX_PIXEL_FORMAT_INT_ARGB8888 && si != NULL)
 400                 memmove(d, si, limit * 4);
 401
 402         /* Almost there. */
 403         else if (g->pixelFormat == SJME_GFX_PIXEL_FORMAT_INT_RGB888 && si != NULL)
 404         {
 405                 /* Copy and put in the mask. */
 406                 for (i = 0; i < limit; i++)
 407                         *(d++) = *(si++) | destAlphaMask;
 408         }
 409
 410         /* Integer mapping. */
 411         else if (si != NULL)
 412         {
 413                 for (i = 0; i < limit; i++)
 414                 {
 415                         t = *(si++);
 416
 417                         error |= sjme_scritchpen_corePrim_mapColorFromRaw(g,
 418                                 t, &color);
 419
 420                         *(d++) = color.argb | destAlphaMask;
 421                 }
 422         }
 423
 424         /* Short mapping. */
 425         else if (ss != NULL)
 426         {
 427                 for (i = 0; i < limit; i++)
 428                 {
 429                         t = *(ss++) & 0xFFFF;
 430
 431                         error |= sjme_scritchpen_corePrim_mapColorFromRaw(g,
 432                                 t, &color);
 433
 434                         *(d++) = color.argb | destAlphaMask;
 435                 }
 436         }
 437
 438         /* Triple byte? */
 439         else if (sb != NULL && mulShift == 3)
 440         {
 441                 for (i = 0; i < limit; i++)
 442                 {
 443                         t = ((sjme_juint)(((*(sb++)) & 0xFF))) << 16;
 444                         t |= ((sjme_juint)(((*(sb++)) & 0xFF))) << 8;
 445                         t |= ((sjme_juint)(((*(sb++)) & 0xFF)));
 446
 447                         error |= sjme_scritchpen_corePrim_mapColorFromRaw(g,
 448                                 t, &color);
 449
 450                         *(d++) = color.argb | destAlphaMask;
 451                 }
 452         }
 453
 454         /* Byte mapping. */
 455         else if (sb != NULL)
 456         {
 457                 for (i = 0; i < limit; i++)
 458                 {
 459                         t = *(sb++) & 0xFF;
 460
 461                         error |= sjme_scritchpen_corePrim_mapColorFromRaw(g,
 462                                 t, &color);
 463
 464                         *(d++) = color.argb | destAlphaMask;
 465                 }
 466         }
 467
 468         /* Unknown. */
 469         else
 470         {
 471                 sjme_todo("Impl?");
 472         }
 473
 474         /* Failed or success? */
 475         if (sjme_error_is(error))
 476                 return sjme_error_default(error);
 477         return SJME_ERROR_NONE;
 478 }
 479
 480 sjme_errorCode sjme_scritchpen_coreUtil_rgbScanFill(
 481         sjme_attrInNotNull sjme_scritchui_pencil g,
 482         sjme_attrOutNotNullBuf(inNumPixels) sjme_jint* outRgb,
 483         sjme_attrInPositiveNonZero sjme_jint outRgbOff,
 484         sjme_attrInPositiveNonZero sjme_jint inNumPixels,
 485         sjme_attrInValue sjme_jint inValue)
 486 {
 487         sjme_jint i;
 488         sjme_jint* p;
 489
 490         if (g == NULL || outRgb == NULL)
 491                 return SJME_ERROR_NULL_ARGUMENTS;
 492
 493         if (outRgbOff < 0 || inNumPixels < 0 ||
 494                 (outRgbOff + inNumPixels) < 0)
 495                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 496
 497         /* Fill in, which is a rather simple operation. */
 498         p = &outRgb[outRgbOff];
 499         for (i = 0; i < inNumPixels; i++)
 500                 *(p++) = inValue;
 501
 502         /* Success! */
 503         return SJME_ERROR_NONE;
 504 }
 505
 506 sjme_errorCode sjme_scritchpen_coreUtil_rgbScanGet(
 507         sjme_attrInNotNull sjme_scritchui_pencil g,
 508         sjme_attrInPositive sjme_jint x,
 509         sjme_attrInPositive sjme_jint y,
 510         sjme_attrOutNotNullBuf(inLen) sjme_jint* destRgb,
 511         sjme_attrInPositiveNonZero sjme_jint inNumPixels)
 512 {
 513         sjme_errorCode error;
 514         sjme_jint ex, rgbBytes, rawScanBytes;
 515         void* rawScan;
 516
 517         if (g == NULL || destRgb == NULL)
 518                 return SJME_ERROR_NONE;
 519
 520         /* We cannot access a region outside the image bounds. */
 521         ex = x + inNumPixels;
 522         rgbBytes = inNumPixels * sizeof(*destRgb);
 523         if (x < 0 || y < 0 || inNumPixels < 0 ||
 524                 ex < 0 || ex > g->width || rgbBytes < 0)
 525                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 526
 527         /* How much data is to be read? */
 528         rawScanBytes = (inNumPixels * g->bitsPerPixel) / 8;
 529         if (rawScanBytes < 0)
 530                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 531
 532         /* Allocate. */
 533         rawScan = sjme_alloca(rawScanBytes);
 534         if (rawScan == NULL)
 535                 return SJME_ERROR_OUT_OF_MEMORY;
 536
 537         /* Clear. */
 538         memset(rawScan, 0, rawScanBytes);
 539
 540         /* Load in from image directly. */
 541         if (sjme_error_is(error = g->prim.rawScanGet(g,
 542                 x, y, rawScan, rawScanBytes, inNumPixels)))
 543                 return sjme_error_default(error);
 544
 545         /* Map to RGB. */
 546         return g->util->rawScanToRgb(g,
 547                 destRgb, 0, inNumPixels,
 548                 rawScan, 0, rawScanBytes);
 549 }
 550
 551 sjme_errorCode sjme_scritchpen_coreUtil_rgbScanPut(
 552         sjme_attrInNotNull sjme_scritchui_pencil g,
 553         sjme_attrInPositive sjme_jint x,
 554         sjme_attrInPositive sjme_jint y,
 555         sjme_attrInNotNullBuf(inLen) const sjme_jint* srcRgb,
 556         sjme_attrInPositiveNonZero sjme_jint inNumPixels,
 557         sjme_attrInValue sjme_jboolean srcAlpha,
 558         sjme_attrInValue sjme_jboolean mulAlpha,
 559         sjme_attrInRange(0, 255) sjme_jint mulAlphaValue)
 560 {
 561         sjme_errorCode error;
 562         sjme_jint ex, rawScanBytes, rgbBytes;
 563         void* rawScan;
 564         sjme_jint* destRgb;
 565
 566         if (g == NULL || srcRgb == NULL)
 567                 return SJME_ERROR_NONE;
 568
 569         /* We cannot access a region outside the image bounds. */
 570         ex = x + inNumPixels;
 571         rgbBytes = inNumPixels * sizeof(*destRgb);
 572         if (x < 0 || y < 0 || inNumPixels < 0 ||
 573                 ex < 0 || ex > g->width || rgbBytes < 0 ||
 574                 (mulAlpha && (mulAlphaValue < 0 || mulAlphaValue > 255)))
 575                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 576
 577         /* How much data is to be written? */
 578         rawScanBytes = (inNumPixels * g->bitsPerPixel) / 8;
 579         if (rawScanBytes < 0)
 580                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 581
 582         /* Do we need to alpha blend? */
 583         if (srcAlpha || mulAlpha)
 584         {
 585                 /* Allocate dest RGB data. */
 586                 destRgb = sjme_alloca(rgbBytes);
 587                 if (destRgb == NULL)
 588                         return SJME_ERROR_OUT_OF_MEMORY;
 589
 590                 /* Clear. */
 591                 memset(destRgb, 0, rgbBytes);
 592
 593                 /* Load in RGB data from image, which might be lossy. */
 594                 if (sjme_error_is(error = g->util->rgbScanGet(g,
 595                         x, y, destRgb, inNumPixels)))
 596                         return sjme_error_default(error);
 597
 598                 /* Perform blending. */
 599                 if (sjme_error_is(error = g->util->blendRGBInto(g,
 600                         g->hasAlpha, srcAlpha,
 601                         mulAlpha, mulAlphaValue,
 602                         destRgb, srcRgb, inNumPixels)))
 603                         return sjme_error_default(error);
 604
 605                 /* The destination becomes the new source. */
 606                 srcRgb = destRgb;
 607         }
 608
 609         /* Allocate raw scan data. */
 610         rawScan = sjme_alloca(rawScanBytes);
 611         if (rawScan == NULL)
 612                 return SJME_ERROR_OUT_OF_MEMORY;
 613
 614         /* Clear. */
 615         memset(rawScan, 0, rawScanBytes);
 616
 617         /* Map from RGB to raw pixels. */
 618         if (sjme_error_is(error = g->util->rgbToRawScan(g,
 619                 rawScan, 0, rawScanBytes,
 620                 srcRgb, 0, inNumPixels)))
 621                 return sjme_error_default(error);
 622
 623         /* Write direct image data. */
 624         return g->prim.rawScanPutPure(g,
 625                 x, y,
 626                 rawScan, rawScanBytes, inNumPixels);
 627 }
 628
 629 sjme_errorCode sjme_scritchpen_coreUtil_rgbToRawScan(
 630         sjme_attrInNotNull sjme_scritchui_pencil g,
 631         sjme_attrOutNotNullBuf(rawLen) void* outRaw,
 632         sjme_attrInPositive sjme_jint outRawOff,
 633         sjme_attrInPositive sjme_jint outRawLen,
 634         sjme_attrInNotNullBuf(rgbLen) const sjme_jint* inRgb,
 635         sjme_attrInPositive sjme_jint inRgbOff,
 636         sjme_attrInPositive sjme_jint inRgbLen)
 637 {
 638         sjme_errorCode error;
 639         sjme_jint limit, i, t, mulShift, j;
 640         sjme_jint* di;
 641         sjme_jshort* ds;
 642         sjme_jbyte* db;
 643         const sjme_jint* s;
 644         sjme_scritchui_pencilColor color;
 645
 646         if (g == NULL || inRgb == NULL || outRaw == NULL)
 647                 return SJME_ERROR_NULL_ARGUMENTS;
 648
 649         if (inRgbOff < 0 || inRgbLen < 0 || (inRgbOff + inRgbLen) < 0 ||
 650                 outRawOff < 0 || outRawLen < 0 || (outRawOff + outRawLen) < 0)
 651                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 652
 653         /* Determine the type to use for scan reading. */
 654         di = NULL;
 655         ds = NULL;
 656         db = NULL;
 657         mulShift = 1;
 658         switch (g->pixelFormat)
 659         {
 660                 case SJME_GFX_PIXEL_FORMAT_INT_ARGB8888:
 661                 case SJME_GFX_PIXEL_FORMAT_INT_RGB888:
 662                 case SJME_GFX_PIXEL_FORMAT_INT_BGRA8888:
 663                 case SJME_GFX_PIXEL_FORMAT_INT_BGRX8888:
 664                 case SJME_GFX_PIXEL_FORMAT_INT_BGR888:
 665                 case SJME_GFX_PIXEL_FORMAT_INT_RGBX8888:
 666                         di = SJME_POINTER_OFFSET(outRaw, outRawOff);
 667                         limit = outRawLen / 4;
 668                         break;
 669
 670                 case SJME_GFX_PIXEL_FORMAT_BYTE3_RGB888:
 671                 case SJME_GFX_PIXEL_FORMAT_BYTE3_BGR888:
 672                         db = SJME_POINTER_OFFSET(outRaw, outRawOff);
 673                         limit = outRawLen / 3;
 674                         mulShift = 3;
 675                         break;
 676
 677                 case SJME_GFX_PIXEL_FORMAT_SHORT_ARGB4444:
 678                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB565:
 679                 case SJME_GFX_PIXEL_FORMAT_SHORT_RGB555:
 680                 case SJME_GFX_PIXEL_FORMAT_SHORT_ABGR1555:
 681                 case SJME_GFX_PIXEL_FORMAT_SHORT_INDEXED65536:
 682                         ds = SJME_POINTER_OFFSET(outRaw, outRawOff);
 683                         limit = outRawLen / 2;
 684                         break;
 685
 686                 case SJME_GFX_PIXEL_FORMAT_BYTE_INDEXED256:
 687                         db = SJME_POINTER_OFFSET(outRaw, outRawOff);
 688                         limit = outRawLen;
 689                         break;
 690
 691                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED4:
 692                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED2:
 693                 case SJME_GFX_PIXEL_FORMAT_PACKED_INDEXED1:
 694                         sjme_todo("Impl?");
 695                         break;
 696
 697                 default:
 698                         return SJME_ERROR_INVALID_ARGUMENT;
 699         }
 700
 701         /* Reading what? */
 702         s = &inRgb[inRgbOff];
 703
 704         /* If the output RGB is smaller than the raw input, limit to it. */
 705         if (inRgbLen < limit)
 706                 limit = inRgbLen;
 707
 708         /* Clear error state. */
 709         error = SJME_ERROR_NONE;
 710
 711         /* Already in the most native format? */
 712         if (g->pixelFormat == SJME_GFX_PIXEL_FORMAT_INT_ARGB8888 && di != NULL)
 713                 memmove(di, s, limit * 4);
 714
 715         /* Almost there. */
 716         else if (g->pixelFormat == SJME_GFX_PIXEL_FORMAT_INT_RGB888 && di != NULL)
 717         {
 718                 /* Copy and put in the mask. */
 719                 for (i = 0; i < limit; i++)
 720                         *(di++) = *(s++);
 721         }
 722
 723         /* Integer mapping. */
 724         else if (di != NULL)
 725         {
 726                 for (i = 0; i < limit; i++)
 727                 {
 728                         t = *(s++);
 729
 730                         error |= sjme_scritchpen_corePrim_mapColorFromRGB(g,
 731                                 t, &color);
 732
 733                         *(di++) = color.v;
 734                 }
 735         }
 736
 737         /* Short mapping. */
 738         else if (ds != NULL)
 739         {
 740                 for (i = 0; i < limit; i++)
 741                 {
 742                         t = *(s++);
 743
 744                         error |= sjme_scritchpen_corePrim_mapColorFromRGB(g,
 745                                 t, &color);
 746
 747                         *(ds++) = color.v & 0xFFFF;
 748                 }
 749         }
 750
 751         /* Triple byte? */
 752         else if (db != NULL && mulShift == 3)
 753         {
 754                 for (i = 0; i < limit; i++)
 755                 {
 756                         t = *(s++);
 757
 758                         error |= sjme_scritchpen_corePrim_mapColorFromRGB(g,
 759                                 t, &color);
 760
 761                         *(db++) = (color.v >> 16) & 0xFF;
 762                         *(db++) = (color.v >> 8) & 0xFF;
 763                         *(db++) = (color.v) & 0xFF;
 764                 }
 765         }
 766
 767         /* Byte mapping. */
 768         else if (db != NULL)
 769         {
 770                 for (i = 0; i < limit; i++)
 771                 {
 772                         t = *(s++);
 773
 774                         error |= sjme_scritchpen_corePrim_mapColorFromRGB(g,
 775                                 t, &color);
 776
 777                         *(db++) = color.v & 0xFF;
 778                 }
 779         }
 780
 781         /* Unknown. */
 782         else
 783         {
 784                 sjme_todo("Impl?");
 785         }
 786
 787         /* Failed or success? */
 788         if (sjme_error_is(error))
 789                 return sjme_error_default(error);
 790         return SJME_ERROR_NONE;
 791 }