workbench/devs/diskimage/png_image/writergbapixels_cgx.c

   1 /* Copyright 2007-2012 Fredrik Wikstrom. All rights reserved.
   2 **
   3 ** Redistribution and use in source and binary forms, with or without
   4 ** modification, are permitted provided that the following conditions
   5 ** are met:
   6 **
   7 ** 1. Redistributions of source code must retain the above copyright
   8 **    notice, this list of conditions and the following disclaimer.
   9 **
  10 ** 2. Redistributions in binary form must reproduce the above copyright
  11 **    notice, this list of conditions and the following disclaimer in the
  12 **    documentation and/or other materials provided with the distribution.
  13 **
  14 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19 ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20 ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22 ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23 ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24 ** POSSIBILITY OF SUCH DAMAGE.
  25 */
  26
  27 #include "class.h"
  28 #include "endian.h"
  29 #include <cybergraphx/cybergraphics.h>
  30 #include <proto/cybergraphics.h>
  31
  32 BOOL IsSupportedRGBFormat_CGX (ULONG rgbformat) {
  33         switch (rgbformat) {
  34                 case PIXFMT_RGB15:
  35                 case PIXFMT_BGR15:
  36                 case PIXFMT_RGB15PC:
  37                 case PIXFMT_BGR15PC:
  38                 case PIXFMT_RGB16:
  39                 case PIXFMT_BGR16:
  40                 case PIXFMT_RGB16PC:
  41                 case PIXFMT_BGR16PC:
  42                 case PIXFMT_RGB24:
  43                 case PIXFMT_BGR24:
  44                 case PIXFMT_ARGB32:
  45                 case PIXFMT_BGRA32:
  46                 case PIXFMT_RGBA32:
  47                         return TRUE;
  48
  49                 default:
  50                         return FALSE;
  51         }
  52 }
  53
  54 IPTR WriteRGBAPixels_CGX (REG(a0, struct Hook *hook), REG(a2, struct RastPort *rp),
  55         REG(a1, struct BackFillMessage *msg))
  56 {
  57         struct HookData *data = hook->h_Data;
  58         WORD x, y, w, h;
  59         ULONG bpp, bpr;
  60         ULONG rgbformat;
  61         APTR lock;
  62         UBYTE *src, *dst;
  63         ULONG src_mod, dst_mod;
  64
  65         w = msg->Bounds.MaxX - msg->Bounds.MinX + 1;
  66         h = msg->Bounds.MaxY - msg->Bounds.MinY + 1;
  67
  68         src = data->image + (msg->OffsetY - data->y) * (data->w * 4UL) + (msg->OffsetX - data->x) * 4UL;
  69         src_mod = (data->w - w) * 4UL;
  70
  71         lock = LockBitMapTags(rp->BitMap,
  72                 LBMI_BASEADDRESS,       &dst,
  73                 LBMI_BYTESPERPIX,       &bpp,
  74                 LBMI_BYTESPERROW,       &bpr,
  75                 LBMI_PIXFMT,            &rgbformat,
  76                 TAG_END);
  77         if (!lock) {
  78                 return 0;
  79         }
  80
  81         dst = dst + msg->Bounds.MinY * bpr + msg->Bounds.MinX * bpp;
  82         dst_mod = bpr - w * bpp;
  83
  84         switch (rgbformat) {
  85                 case PIXFMT_RGB16:
  86                         {
  87                                 UWORD rgb;
  88                                 UWORD a6, a5;
  89                                 UWORD r, g, b;
  90                                 for (y = 0; y < h; y++) {
  91                                         for (x = 0; x < w; x++) {
  92                                                 a6 = src[3] >> 2;
  93                                                 a5 = src[3] >> 3;
  94                                                 if (a6 != 63) {
  95                                                         rgb = rbe16(dst);
  96                                                         r = (src[0] >> 3) + ((a5 * ((rgb >> 11) & 31)) >> 5);
  97                                                         g = (src[1] >> 2) + ((a6 * ((rgb >> 5) & 63)) >> 6);
  98                                                         b = (src[2] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
  99                                                         wbe16(dst, (r << 11)|(g << 5)|(b));
 100                                                 }
 101                                                 src += 4;
 102                                                 dst += 2;
 103                                         }
 104                                         src += src_mod;
 105                                         dst += dst_mod;
 106                                 }
 107                         }
 108                         break;
 109
 110                 case PIXFMT_RGB16PC:
 111                         {
 112                                 UWORD rgb;
 113                                 UWORD a6, a5;
 114                                 UWORD r, g, b;
 115                                 for (y = 0; y < h; y++) {
 116                                         for (x = 0; x < w; x++) {
 117                                                 a6 = src[3] >> 2;
 118                                                 a5 = src[3] >> 3;
 119                                                 if (a6 != 63) {
 120                                                         rgb = rle16(dst);
 121                                                         r = (src[0] >> 3) + ((a5 * ((rgb >> 11) & 31)) >> 5);
 122                                                         g = (src[1] >> 2) + ((a6 * ((rgb >> 5) & 63)) >> 6);
 123                                                         b = (src[2] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 124                                                         wle16(dst, (r << 11)|(g << 5)|(b));
 125                                                 }
 126                                                 src += 4;
 127                                                 dst += 2;
 128                                         }
 129                                         src += src_mod;
 130                                         dst += dst_mod;
 131                                 }
 132                         }
 133                         break;
 134
 135                 case PIXFMT_BGR16:
 136                         {
 137                                 UWORD rgb;
 138                                 UWORD a6, a5;
 139                                 UWORD r, g, b;
 140                                 for (y = 0; y < h; y++) {
 141                                         for (x = 0; x < w; x++) {
 142                                                 a6 = src[3] >> 2;
 143                                                 a5 = src[3] >> 3;
 144                                                 if (a6 != 63) {
 145                                                         rgb = rbe16(dst);
 146                                                         b = (src[2] >> 3) + ((a5 * ((rgb >> 11) & 31)) >> 5);
 147                                                         g = (src[1] >> 2) + ((a6 * ((rgb >> 5) & 63)) >> 6);
 148                                                         r = (src[0] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 149                                                         wbe16(dst, (b << 11)|(g << 5)|(r));
 150                                                 }
 151                                                 src += 4;
 152                                                 dst += 2;
 153                                         }
 154                                         src += src_mod;
 155                                         dst += dst_mod;
 156                                 }
 157                         }
 158                         break;
 159
 160                 case PIXFMT_BGR16PC:
 161                         {
 162                                 UWORD rgb;
 163                                 UWORD a6, a5;
 164                                 UWORD r, g, b;
 165                                 for (y = 0; y < h; y++) {
 166                                         for (x = 0; x < w; x++) {
 167                                                 a6 = src[3] >> 2;
 168                                                 a5 = src[3] >> 3;
 169                                                 if (a6 != 63) {
 170                                                         rgb = rle16(dst);
 171                                                         b = (src[2] >> 3) + ((a5 * ((rgb >> 11) & 31)) >> 5);
 172                                                         g = (src[1] >> 2) + ((a6 * ((rgb >> 5) & 63)) >> 6);
 173                                                         r = (src[0] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 174                                                         wle16(dst, (b << 11)|(g << 5)|(r));
 175                                                 }
 176                                                 src += 4;
 177                                                 dst += 2;
 178                                         }
 179                                         src += src_mod;
 180                                         dst += dst_mod;
 181                                 }
 182                         }
 183                         break;
 184
 185                 case PIXFMT_RGB15:
 186                         {
 187                                 UWORD rgb;
 188                                 UWORD a5;
 189                                 UWORD r, g, b;
 190                                 for (y = 0; y < h; y++) {
 191                                         for (x = 0; x < w; x++) {
 192                                                 a5 = src[3] >> 3;
 193                                                 if (a5 != 31) {
 194                                                         rgb = rbe16(dst);
 195                                                         r = (src[0] >> 3) + ((a5 * ((rgb >> 10) & 31)) >> 5);
 196                                                         g = (src[1] >> 3) + ((a5 * ((rgb >> 5) & 31)) >> 5);
 197                                                         b = (src[2] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 198                                                         wbe16(dst, (r << 10)|(g << 5)|(b));
 199                                                 }
 200                                                 src += 4;
 201                                                 dst += 2;
 202                                         }
 203                                         src += src_mod;
 204                                         dst += dst_mod;
 205                                 }
 206                         }
 207                         break;
 208
 209                 case PIXFMT_RGB15PC:
 210                         {
 211                                 UWORD rgb;
 212                                 UWORD a5;
 213                                 UWORD r, g, b;
 214                                 for (y = 0; y < h; y++) {
 215                                         for (x = 0; x < w; x++) {
 216                                                 a5 = src[3] >> 3;
 217                                                 if (a5 != 31) {
 218                                                         rgb = rle16(dst);
 219                                                         r = (src[0] >> 3) + ((a5 * ((rgb >> 10) & 31)) >> 5);
 220                                                         g = (src[1] >> 3) + ((a5 * ((rgb >> 5) & 31)) >> 5);
 221                                                         b = (src[2] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 222                                                         wle16(dst, (r << 10)|(g << 5)|(b));
 223                                                 }
 224                                                 src += 4;
 225                                                 dst += 2;
 226                                         }
 227                                         src += src_mod;
 228                                         dst += dst_mod;
 229                                 }
 230                         }
 231                         break;
 232
 233                 case PIXFMT_BGR15:
 234                         {
 235                                 UWORD rgb;
 236                                 UWORD a5;
 237                                 UWORD r, g, b;
 238                                 for (y = 0; y < h; y++) {
 239                                         for (x = 0; x < w; x++) {
 240                                                 a5 = src[3] >> 3;
 241                                                 if (a5 != 31) {
 242                                                         rgb = rbe16(dst);
 243                                                         b = (src[2] >> 3) + ((a5 * ((rgb >> 10) & 31)) >> 5);
 244                                                         g = (src[1] >> 3) + ((a5 * ((rgb >> 5) & 31)) >> 5);
 245                                                         r = (src[0] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 246                                                         wbe16(dst, (b << 10)|(g << 5)|(r));
 247                                                 }
 248                                                 src += 4;
 249                                                 dst += 2;
 250                                         }
 251                                         src += src_mod;
 252                                         dst += dst_mod;
 253                                 }
 254                         }
 255                         break;
 256
 257                 case PIXFMT_BGR15PC:
 258                         {
 259                                 UWORD rgb;
 260                                 UWORD a5;
 261                                 UWORD r, g, b;
 262                                 for (y = 0; y < h; y++) {
 263                                         for (x = 0; x < w; x++) {
 264                                                 a5 = src[3] >> 3;
 265                                                 if (a5 != 31) {
 266                                                         rgb = rle16(dst);
 267                                                         b = (src[2] >> 3) + ((a5 * ((rgb >> 10) & 31)) >> 5);
 268                                                         g = (src[1] >> 3) + ((a5 * ((rgb >> 5) & 31)) >> 5);
 269                                                         r = (src[0] >> 3) + ((a5 * ((rgb) & 31)) >> 5);
 270                                                         wle16(dst, (b << 10)|(g << 5)|(r));
 271                                                 }
 272                                                 src += 4;
 273                                                 dst += 2;
 274                                         }
 275                                         src += src_mod;
 276                                         dst += dst_mod;
 277                                 }
 278                         }
 279                         break;
 280
 281                 case PIXFMT_ARGB32:
 282                 case PIXFMT_RGBA32:
 283                 case PIXFMT_RGB24:
 284                         {
 285                                 BOOL pre, post;
 286                                 UWORD a;
 287                                 pre = (rgbformat == PIXFMT_ARGB32);
 288                                 post = (rgbformat == PIXFMT_RGBA32);
 289                                 for (y = 0; y < h; y++) {
 290                                         for (x = 0; x < w; x++) {
 291                                                 a = src[3];
 292                                                 if (pre) dst++;
 293                                                 if (a != 255) {
 294                                                         dst[0] = src[0] + ((a * dst[0]) >> 8);
 295                                                         dst[1] = src[1] + ((a * dst[1]) >> 8);
 296                                                         dst[2] = src[2] + ((a * dst[2]) >> 8);
 297                                                 }
 298                                                 if (post) dst++;
 299                                                 src += 4;
 300                                                 dst += 3;
 301                                         }
 302                                         src += src_mod;
 303                                         dst += dst_mod;
 304                                 }
 305                         }
 306                         break;
 307
 308                 case PIXFMT_BGRA32:
 309                 case PIXFMT_BGR24:
 310                         {
 311                                 BOOL post;
 312                                 UWORD a;
 313                                 post = (rgbformat == PIXFMT_BGRA32);
 314                                 for (y = 0; y < h; y++) {
 315                                         for (x = 0; x < w; x++) {
 316                                                 a = src[3];
 317                                                 if (a != 255) {
 318                                                         dst[0] = src[2] + ((a * dst[0]) >> 8);
 319                                                         dst[1] = src[1] + ((a * dst[1]) >> 8);
 320                                                         dst[2] = src[0] + ((a * dst[2]) >> 8);
 321                                                 }
 322                                                 if (post) dst++;
 323                                                 src += 4;
 324                                                 dst += 3;
 325                                         }
 326                                         src += src_mod;
 327                                         dst += dst_mod;
 328                                 }
 329                         }
 330                         break;
 331         }
 332
 333         UnLockBitMap(lock);
 334
 335         return 0;
 336 }