rom/graphics/bitmapscale.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics function BitMapScale()
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <graphics/scale.h>
  11 #include <proto/exec.h>
  12 #include <proto/oop.h>
  13
  14 #include "graphics_intern.h"
  15 #include "gfxfuncsupport.h"
  16 #include "objcache.h"
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <proto/graphics.h>
  22
  23         AROS_LH1(void, BitMapScale,
  24
  25 /*  SYNOPSIS */
  26         AROS_LHA(struct BitScaleArgs *, bitScaleArgs, A0),
  27
  28 /*  LOCATION */
  29         struct GfxBase *, GfxBase, 113, Graphics)
  30
  31 /*  FUNCTION
  32         Scale a source bit map to a destination bit map other than
  33         the source bit map.
  34
  35     INPUTS
  36         Pass a BitScaleArgs structure filled with the following arguments
  37         to this function:
  38           bsa_SrcX, bsa_SrcY - upper left coordinate in source bitmap
  39           bsa_SrcWidth, bsa_SrcHeight - Width and Height of source bitmap
  40           bsa_DestX, bsa_DestY - upper left coordinate in destination
  41                                  bitmap
  42           bsa_DestWidth, bsa_DestHeight - this function will set these
  43                 values. Use the bsa_???Factor for scaling
  44           bsa_XSrcFactor:bsa_XDestFactor - Set these to get approximately
  45                 the same ratio as bsa_SrcWidth:bsa_DestWidth, but
  46                 usually not exactly the same number.
  47           bsa_YSrcFactor:bsa_YDestFactor - Set these to get approximately
  48                 the same ratio as bsa_SrcHeight:DestHeight, but
  49                 usually not exactly the same number.
  50           bsa_SrcBitMap - pointer to source bitmap to be scaled
  51           bsa_DestBitMap - pointer to destination bitmap which will
  52                            hold the scaled bitmap. Make sure it's
  53                            big enough!
  54           bsa_Flags - reserved for future use. Set it to zero!
  55           bsa_XDDA, bsa_YDDA - for future use.
  56           bsa_Reserved1, bsa_Reserved2 - for future use.
  57
  58     RESULT
  59           bsa_DestWidth and bsa_DestHeight will be set by this function
  60
  61     NOTES
  62         - Overlapping source and destination bitmaps are not supported
  63         - Make sure that you provide enough memory for the destination
  64           bitmap to hold the result
  65         - In the destination bitmap only the area where the scaled
  66           source bitmap is put into is changed. A frame of the old
  67           bitmap is left.
  68
  69     EXAMPLE
  70
  71     BUGS
  72
  73     SEE ALSO
  74         ScalerDiv(), graphics/scale.h
  75
  76     INTERNALS
  77
  78     HISTORY
  79
  80 *****************************************************************************/
  81 {
  82   AROS_LIBFUNC_INIT
  83
  84   if (IS_HIDD_BM(bitScaleArgs->bsa_SrcBitMap) ||
  85       IS_HIDD_BM(bitScaleArgs->bsa_DestBitMap))
  86   {
  87     ULONG srcflags = 0;
  88     ULONG dstflags = 0;
  89
  90     BOOL src_colmap_set = FALSE;
  91     BOOL dst_colmap_set = FALSE;
  92     BOOL success = TRUE;
  93     BOOL colmaps_ok = TRUE;
  94
  95     OOP_Object *srcbm_obj;
  96     OOP_Object *dstbm_obj;
  97     OOP_Object *tmp_gc;
  98
  99     srcbm_obj = OBTAIN_HIDD_BM(bitScaleArgs->bsa_SrcBitMap);
 100     dstbm_obj = OBTAIN_HIDD_BM(bitScaleArgs->bsa_DestBitMap);
 101     tmp_gc    = obtain_cache_object(CDD(GfxBase)->gc_cache, GfxBase);
 102
 103     /* We must lock any HIDD_BM_SetColorMap calls */
 104     LOCK_BLIT
 105     if (srcbm_obj && dstbm_obj && tmp_gc)
 106     {
 107         /* Try to get a CLUT for the bitmaps */
 108         if (IS_HIDD_BM(bitScaleArgs->bsa_SrcBitMap)) {
 109             if (NULL != HIDD_BM_COLMAP(bitScaleArgs->bsa_SrcBitMap))
 110                 srcflags |= FLG_HASCOLMAP;
 111             srcflags |= GET_COLMOD_FLAGS(bitScaleArgs->bsa_SrcBitMap);
 112         } else {
 113              /* Amiga BM */
 114              srcflags |= FLG_PALETTE;
 115         }
 116
 117         if (IS_HIDD_BM(bitScaleArgs->bsa_DestBitMap)) {
 118             if (NULL != HIDD_BM_COLMAP(bitScaleArgs->bsa_DestBitMap))
 119                dstflags |= FLG_HASCOLMAP;
 120             dstflags |= GET_COLMOD_FLAGS(bitScaleArgs->bsa_DestBitMap);
 121         } else {
 122             /* Amiga BM */
 123             dstflags |= FLG_PALETTE;
 124         }
 125
 126
 127         if (    (srcflags == FLG_PALETTE || srcflags == FLG_STATICPALETTE)) {
 128             /* palettized with no colmap. Need to get a colmap from dest */
 129             if (dstflags == FLG_TRUECOLOR) {
 130
 131                 D(bug("!!! NO WAY GETTING PALETTE FOR src IN BltBitMap\n"));
 132                 colmaps_ok = FALSE;
 133                 success = FALSE;
 134
 135             } else if (dstflags == (FLG_TRUECOLOR | FLG_HASCOLMAP)) {
 136
 137                 /* Use the dest colmap for src */
 138                 HIDD_BM_SetColorMap(srcbm_obj, HIDD_BM_COLMAP(bitScaleArgs->bsa_DestBitMap));
 139
 140             }
 141         }
 142
 143         if (   (dstflags == FLG_PALETTE || dstflags == FLG_STATICPALETTE)) {
 144             /* palettized with no pixtab. Need to get a pixtab from dest */
 145             if (srcflags == FLG_TRUECOLOR) {
 146                 D(bug("!!! NO WAY GETTING PALETTE FOR dst IN BltBitMap\n"));
 147                 colmaps_ok = FALSE;
 148                 success = FALSE;
 149
 150             } else if (srcflags == (FLG_TRUECOLOR | FLG_HASCOLMAP)) {
 151
 152                 /* Use the src colmap for dst */
 153                 HIDD_BM_SetColorMap(dstbm_obj, HIDD_BM_COLMAP(bitScaleArgs->bsa_SrcBitMap));
 154
 155                 dst_colmap_set = TRUE;
 156             }
 157         }
 158
 159         if (success && colmaps_ok)
 160         {
 161             struct monitor_driverdata *driver, *dst_driver;
 162             OOP_Object *bm_obj;
 163             HIDDT_DrawMode old_drmd;
 164             struct TagItem cbtags[] = {
 165                 { aHidd_GC_DrawMode, vHidd_GC_DrawMode_Copy },
 166                 { TAG_DONE, 0 }
 167             };
 168
 169             OOP_GetAttr(tmp_gc, aHidd_GC_DrawMode, &old_drmd);
 170             OOP_SetAttrs(tmp_gc, cbtags);
 171
 172             bitScaleArgs->bsa_DestWidth = ScalerDiv(bitScaleArgs->bsa_SrcWidth,
 173                                            bitScaleArgs->bsa_XDestFactor,
 174                                            bitScaleArgs->bsa_XSrcFactor);
 175
 176             bitScaleArgs->bsa_DestHeight = ScalerDiv(bitScaleArgs->bsa_SrcHeight,
 177                                             bitScaleArgs->bsa_YDestFactor,
 178                                             bitScaleArgs->bsa_YSrcFactor);
 179
 180             /*
 181              * Select a driver to call. The same as in BltBitMap(), but select
 182              * bitmap object instead of driver object.
 183              */
 184             driver     = GET_BM_DRIVERDATA(bitScaleArgs->bsa_SrcBitMap);
 185             dst_driver = GET_BM_DRIVERDATA(bitScaleArgs->bsa_DestBitMap);
 186
 187             if (driver == (struct monitor_driverdata *)CDD(GfxBase))
 188                 bm_obj = dstbm_obj;
 189             else if (dst_driver->flags & DF_UseFakeGfx)
 190                 bm_obj = dstbm_obj;
 191             else
 192                 bm_obj = srcbm_obj;
 193
 194             HIDD_BM_BitMapScale(bm_obj
 195                 , srcbm_obj
 196                 , dstbm_obj
 197                 , bitScaleArgs
 198                 , tmp_gc
 199             );
 200             update_bitmap(bitScaleArgs->bsa_DestBitMap, dstbm_obj,
 201                           bitScaleArgs->bsa_DestX, bitScaleArgs->bsa_DestY,
 202                           bitScaleArgs->bsa_DestWidth, bitScaleArgs->bsa_DestHeight,
 203                           GfxBase);
 204
 205             cbtags[0].ti_Data = old_drmd;
 206             OOP_SetAttrs(tmp_gc, cbtags);
 207         } /* if () */
 208
 209         if (src_colmap_set)
 210             HIDD_BM_SetColorMap(srcbm_obj, NULL);
 211         if (dst_colmap_set)
 212             HIDD_BM_SetColorMap(dstbm_obj, NULL);
 213     }
 214
 215     if (dstbm_obj)
 216          RELEASE_HIDD_BM(dstbm_obj, bitScaleArgs->bsa_DestBitMap);
 217
 218     if (srcbm_obj)
 219          RELEASE_HIDD_BM(srcbm_obj, bitScaleArgs->bsa_SrcBitMap);
 220
 221     if (tmp_gc)
 222         release_cache_object(CDD(GfxBase)->gc_cache, tmp_gc, GfxBase);
 223
 224     ULOCK_BLIT
 225
 226   }
 227   else
 228   {
 229     /*
 230      * Algorithm for plain Amiga bitmaps.
 231      */
 232     /*
 233      * Unfortunately it's not possible to use 16/32 bit copying on bitmaps with this
 234      * algorithm as there might be an odd number of bits per line in a bitmap and
 235      * this creates problems when accessing the 2nd, 4th and so on line.
 236      */
 237
 238   /*
 239     #define DEF_USIZE ULONG
 240     #define DEF_SIZE LONG
 241     #define DEF_NUMBITSMINUS1 31
 242     #define DEF_MASK 31
 243     #define DEF_READMASK 0x80000000
 244     #define DEF_SHIFTY 2
 245     #define DEF_SHIFTX 5
 246   */
 247
 248   /*  The following lines are necessary for BYTE copying and have to be used right
 249    *  now!!
 250    */
 251
 252     #define DEF_USIZE UBYTE
 253     #define DEF_SIZE BYTE
 254     #define DEF_NUMBITSMINUS1 7
 255     #define DEF_ANDMASK 7
 256     #define DEF_READMASK 0x80
 257     #define DEF_SHIFTY 0
 258     #define DEF_SHIFTX 3
 259
 260     UWORD * LinePattern;
 261     bitScaleArgs -> bsa_DestWidth = ScalerDiv(bitScaleArgs -> bsa_SrcWidth,
 262                                               bitScaleArgs -> bsa_XDestFactor,
 263                                               bitScaleArgs -> bsa_XSrcFactor);
 264
 265     bitScaleArgs -> bsa_DestHeight= ScalerDiv(bitScaleArgs -> bsa_SrcHeight,
 266                                               bitScaleArgs -> bsa_YDestFactor,
 267                                               bitScaleArgs -> bsa_YSrcFactor);
 268
 269     /* first of all lets allocate DestHeight words of memory so we can
 270        precalculate which original line goes to which destination lines */
 271
 272     if (NULL ==(LinePattern = (UWORD *) AllocMem(sizeof(UWORD)*bitScaleArgs ->bsa_DestHeight, 0)))
 273       return;
 274
 275     {
 276       UWORD DestHeight = bitScaleArgs -> bsa_DestHeight;
 277       UWORD ys = bitScaleArgs -> bsa_SrcY;
 278       ULONG count = 0;
 279       ULONG dyd = bitScaleArgs -> bsa_DestHeight;
 280       ULONG dys = bitScaleArgs -> bsa_SrcHeight;
 281       LONG accuys = dyd;
 282       LONG accuyd = - (dys >> 1);
 283       while (count < DestHeight)
 284       {
 285         accuyd += dys;
 286         while (accuyd > accuys )
 287         {
 288           ys++;
 289           accuys += dyd;
 290         }
 291         LinePattern[count] = ys;
 292         count++;
 293       }
 294     }
 295
 296
 297
 298     /* now let's go for the real thing: scaling */
 299     {
 300       UWORD DestWidth = bitScaleArgs -> bsa_DestWidth + bitScaleArgs -> bsa_DestX;
 301       ULONG xs = bitScaleArgs -> bsa_SrcX;
 302       ULONG count = bitScaleArgs -> bsa_DestX;
 303       ULONG dxd = bitScaleArgs -> bsa_DestWidth;
 304       ULONG dxs = bitScaleArgs -> bsa_SrcWidth;
 305       LONG accuxs = dxd;
 306       LONG accuxd = - (dxs >> 1);
 307       DEF_USIZE ReadMask;
 308       ULONG possible_columns, columncounter;
 309       ULONG this_x;
 310
 311       while (count < DestWidth)
 312       {
 313         accuxd += dxs;
 314         while (accuxd > accuxs )
 315         {
 316           xs++;
 317           accuxs += dxd;
 318         }
 319
 320         /* instead of copying column by column we can *maybe* even
 321            copy more than one column at a time - we'll have to see */
 322
 323         if ((count & DEF_ANDMASK) > (xs & DEF_ANDMASK))
 324           possible_columns =  DEF_NUMBITSMINUS1 - (count & DEF_ANDMASK);
 325         else
 326           possible_columns =  DEF_NUMBITSMINUS1 - (xs & DEF_ANDMASK);
 327
 328         columncounter = 1; /* one row, that's for sure!*/
 329         this_x = xs; /* in counter we find the x-coord of the current source pixels  */
 330         {
 331           LONG accuxd_tmp = accuxd;
 332           LONG accuxs_tmp = accuxs;
 333           ULONG next_x = xs;
 334           ULONG count2 = count + 1;
 335
 336           while (possible_columns > 0 && count2 < DestWidth)
 337           {
 338              /* where's the next x-source-coordinate going to be? */
 339             accuxd_tmp += dxs;
 340             while (accuxd_tmp > accuxs_tmp )
 341             {
 342               next_x++;
 343               accuxs_tmp += dxd;
 344             }
 345
 346             if (this_x + 1 == next_x)
 347             {
 348               /* it's the immediately following coordinate */
 349               columncounter++;
 350               this_x++;
 351               count2++;
 352             }
 353             else
 354             {
 355               /* we're copying more than on column then we have to change
 356                * accuxd and accuxs
 357                */
 358               if (columncounter != 1)
 359               {
 360                 accuxd = accuxd_tmp;
 361                 accuxs = accuxs_tmp;
 362               }
 363               break; /* the next column is not the neighbouring one */
 364             }
 365
 366             /* determine how many more columns we can copy */
 367             possible_columns--;
 368           } /* while */
 369         }
 370
 371
 372         /* let's generate a mask that's columncounter bits wide */
 373         ReadMask = DEF_READMASK;
 374         ReadMask = (DEF_SIZE)ReadMask >> (columncounter - 1);
 375         /* let's adjust this mask to the correct position */
 376         ReadMask = ReadMask >> (xs & DEF_ANDMASK);
 377         /* The leftmost set bit is xs & DEF_MASK away from the highest bit */
 378
 379         /* now that we have generated the read-mask we can copy all the columns
 380          * that need copying in all bitmaps.
 381          */
 382
 383         {
 384           ULONG i,y;
 385           ULONG ind;
 386           LONG preshift = (xs & DEF_ANDMASK) - (count & DEF_ANDMASK);
 387           ULONG shift;
 388           ULONG AndMask;
 389           struct BitMap * SrcBitMap  = bitScaleArgs -> bsa_SrcBitMap;
 390           struct BitMap * DestBitMap = bitScaleArgs -> bsa_DestBitMap;
 391
 392           if (preshift > 0)
 393           {
 394             shift = preshift;
 395             AndMask = (ReadMask << shift) ^ (DEF_SIZE)(-1);
 396           }
 397           else
 398           {
 399             shift = -preshift;
 400             AndMask = (ReadMask >> shift) ^ (DEF_SIZE)(-1);
 401           }
 402
 403           /* treat all the Bitmaps after another */
 404           for (i = 0; (i < DestBitMap -> Depth) && (i < SrcBitMap -> Depth); i++)
 405           {
 406             for (y = 0; y < bitScaleArgs -> bsa_DestHeight; y++)
 407             {
 408               DEF_USIZE CopyData;
 409               ind = LinePattern[y] * (SrcBitMap -> BytesPerRow >> DEF_SHIFTY) + /* y-Coord */
 410                     (xs >> DEF_SHIFTX); /* x-Coord */
 411               CopyData = ((DEF_USIZE *)SrcBitMap -> Planes[i])[ind];
 412               CopyData = CopyData & ReadMask;
 413
 414               if (preshift > 0)
 415                 CopyData = CopyData << shift;
 416               else
 417                 CopyData = CopyData >> shift;
 418
 419               /* ind correctly calculates the destination Address for the CopyData */
 420               ind = y * ((bitScaleArgs -> bsa_DestY + DestBitMap -> BytesPerRow) >> DEF_SHIFTY) + /* y-Coord */
 421                     (count >> DEF_SHIFTX); /* x-Coord */
 422               /*  Leave a previous picture in the bitmap untouched except for in the
 423                *  area where the scaled picture goes into
 424                */
 425               ((DEF_USIZE *)DestBitMap ->Planes[i])[ind] =
 426                 (((DEF_USIZE *)DestBitMap ->Planes[i])[ind] & AndMask) | CopyData;
 427               /*
 428                kprintf("Dest: %x\n\n",(LONG)((DEF_USIZE *)DestBitMap ->Planes[i])[ind]);
 429               */
 430             } /* for () */
 431           } /* for () */
 432         }
 433         xs = this_x;
 434
 435         /* go to next x-coordinate */
 436         count += columncounter;
 437       } /* while */
 438     }
 439
 440     /* let's get rid of the allocated memory */
 441     FreeMem(LinePattern, sizeof(UWORD) * bitScaleArgs -> bsa_DestHeight);
 442
 443     #undef DEF_USIZE
 444     #undef DEF_SIZE
 445     #undef DEF_NUMBITSMINUS1
 446     #undef DEF_ANDMASK
 447     #undef DEF_READMASK
 448     #undef DEF_SHIFTY
 449     #undef DEF_SHIFTX
 450   }
 451
 452   AROS_LIBFUNC_EXIT
 453 } /* BitMapScale */