rom/graphics/bitmapscale.c

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