rom/graphics/graphics_intern.h

   1 #ifndef GRAPHICS_INTERN_H
   2 #define GRAPHICS_INTERN_H
   3 /*
   4     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   5     $Id$
   6
   7     Desc: Internal header file for graphics.library
   8     Lang: english
   9 */
  10
  11 #ifndef AROS_LIBCALL_H
  12 #   include <aros/libcall.h>
  13 #endif
  14 #ifndef EXEC_EXECBASE_H
  15 #   include <exec/execbase.h>
  16 #endif
  17 #ifndef EXEC_LISTS_H
  18 #   include <exec/lists.h>
  19 #endif
  20 #ifndef EXEC_NODES_H
  21 #   include <exec/nodes.h>
  22 #endif
  23 #ifndef EXEC_SEMAPHORE_H
  24 #   include <exec/semaphores.h>
  25 #endif
  26 #ifndef GRAPHICS_GFXBASE_H
  27 #   include <graphics/gfxbase.h>
  28 #endif
  29 #ifndef GRAPHICS_TEXT_H
  30 #   include <graphics/text.h>
  31 #endif
  32 #ifndef GRAPHICS_RASTPORT_H
  33 #   include <graphics/rastport.h>
  34 #endif
  35 #ifndef GRAPHICS_REGIONS_H
  36 #   include <graphics/regions.h>
  37 #endif
  38 #ifndef OOP_OOP_H
  39 #   include <oop/oop.h>
  40 #endif
  41 #ifndef GRAPHICS_VIEW_H
  42 #   include <graphics/view.h>
  43 #endif
  44 #ifndef HIDD_GRAPHICS_H
  45 #   include <hidd/graphics.h>
  46 #endif
  47
  48 #include <exec/memory.h>
  49 #include <proto/exec.h>
  50 #include <graphics/scale.h>
  51 #include "fontsupport.h"
  52 #include "objcache.h"
  53
  54 #define BITMAP_CLIPPING         1
  55
  56 #define REGIONS_USE_MEMPOOL     1
  57
  58 /* Setting BMDEPTH_COMPATIBILITY to 1 will cause bitmap->Depth
  59    to be never bigger than 8. The same seems to be the case under
  60    AmigaOS with CyberGraphX/Picasso96. GetBitMapAttr() OTOH will
  61    actually return the real depth. */
  62
  63 #define BMDEPTH_COMPATIBILITY   1
  64
  65 #define OBTAIN_DRIVERDATA(rp,libbase)   ObtainDriverData(rp, libbase)
  66 #define RELEASE_DRIVERDATA(rp,libbase)  ReleaseDriverData(rp, libbase)
  67
  68 #define SIZERECTBUF 128
  69
  70 struct RegionRectangleExt
  71 {
  72     struct RegionRectangle     RR;
  73     IPTR                       Counter;
  74 };
  75
  76 struct RegionRectangleExtChunk
  77 {
  78      struct RegionRectangleExt       Rects[SIZERECTBUF];
  79      struct RegionRectangleExtChunk *FirstChunk;
  80 };
  81
  82 #define RRE(x)     ((struct RegionRectangleExt *)(x))
  83 #define Counter(x) (RRE(x)->Counter)
  84 #define Chunk(x)   ((x) ? ((struct RegionRectangleExtChunk *)&RRE(x)[-Counter(x)]) : NULL)
  85
  86 /* PaletteExtra internals */
  87
  88 typedef WORD PalExtra_RefCnt_Type;
  89 typedef WORD PalExtra_AllocList_Type;
  90
  91 #define PALEXTRA_REFCNT(pe,n)       (((PalExtra_RefCnt_Type *)(pe)->pe_RefCnt)[(n)])
  92 #define PALEXTRA_ALLOCLIST(pe,n)    (((PalExtra_AllocList_Type *)(pe)->pe_AllocList)[(n)])
  93
  94 /*
  95  * Display mode database item. A pointer to this structure is used as a DisplayInfoHandle.
  96  * In future, if needed, this structure can be extended to hold static bunches of associated
  97  * DisplayInfoData.
  98  */
  99
 100 struct monitor_driverdata;
 101
 102 struct DisplayInfoHandle
 103 {
 104     HIDDT_ModeID               id;      /* HIDD Mode ID (without card ID)           */
 105     struct monitor_driverdata *drv;     /* Points back to display driver descriptor */
 106 };
 107
 108 #define DIH(x) ((struct DisplayInfoHandle *)x)
 109
 110 /* Monitor driver data. Describes a single physical display. */
 111 struct monitor_driverdata
 112 {
 113     struct monitor_driverdata *next;            /* Next driver data in chain                      */
 114     ULONG                      id;              /* Card ID (part of display mode ID)              */
 115     ULONG                      mask;            /* Mask of mode ID                                */
 116     OOP_Object                *gfxhidd;         /* Graphics driver to use (can be fakegfx object) */
 117     ObjectCache               *gc_cache;        /* GC cache                                       */
 118     UWORD                      flags;           /* Flags, see below                               */
 119
 120     APTR                       userdata;        /* Associated data from notification callback     */
 121     struct HIDD_ViewPortData  *display;         /* What is currently displayed                    */
 122
 123     /* FakeGfx-related */
 124     OOP_Object                *gfxhidd_orig;    /* Real graphics driver object                    */
 125
 126     /* Framebuffer stuff */
 127     struct BitMap             *frontbm;         /* Currently shown bitmap                         */
 128     OOP_Object                *framebuffer;     /* Framebuffer bitmap object                      */
 129     OOP_Object                *bm_bak;          /* Original shown bitmap object                   */
 130     OOP_Object                *colmap_bak;      /* Original colormap object of shown bitmap       */
 131     HIDDT_ColorModel          colmod_bak;       /* Original colormodel of shown bitmap            */
 132
 133     /* Display mode database. */
 134     struct DisplayInfoHandle  modes[1];         /* Display modes array                            */
 135 };
 136
 137 /* Driver flags */
 138 #define DF_BootMode   0x0001
 139 #define DF_UseFakeGfx 0x0002
 140
 141 /* Common driver data data to all monitors */
 142 struct common_driverdata
 143 {
 144     /* The order of these fields match struct monitor_driverdata */
 145     struct monitor_driverdata *monitors;                /* First monitor driver            */
 146     ULONG                      invalid_id;              /* INVALID_ID, for GET_BM_MODEID() */
 147     ULONG                      last_id;                 /* Last card ID                    */
 148     OOP_Object                *memorygfx;               /* Memory graphics driver          */
 149     ObjectCache               *gc_cache;                /* GC cache                        */
 150     UWORD                      flags;                   /* Always zero                     */
 151
 152     /* End of driverdata */
 153     APTR                       notify_data;                   /* User data for notification callback  */
 154     APTR (*DriverNotify)(APTR obj, BOOL add, APTR userdata); /* Display driver notification callback */
 155     struct SignalSemaphore     displaydb_sem;           /* Display mode database semaphore */
 156
 157     ObjectCache               *planarbm_cache;          /* Planar bitmaps cache            */
 158
 159     /* Fakegfx classes */
 160     OOP_Class                 *fakegfxclass;
 161     OOP_Class                 *fakefbclass;
 162
 163     /* Attribute bases */
 164     OOP_AttrBase             hiddBitMapAttrBase;
 165     OOP_AttrBase             hiddGCAttrBase;
 166     OOP_AttrBase             hiddSyncAttrBase;
 167     OOP_AttrBase             hiddPixFmtAttrBase;
 168     OOP_AttrBase             hiddPlanarBMAttrBase;
 169     OOP_AttrBase             hiddGfxAttrBase;
 170     OOP_AttrBase             hiddFakeGfxHiddAttrBase;
 171     OOP_AttrBase             hiddFakeFBAttrBase;
 172 };
 173
 174 #define CDD(base)           ((struct common_driverdata *)&PrivGBase(base)->shared_driverdata)
 175
 176 #define __IHidd_BitMap      CDD(GfxBase)->hiddBitMapAttrBase
 177 #define __IHidd_GC          CDD(GfxBase)->hiddGCAttrBase
 178 #define __IHidd_Sync        CDD(GfxBase)->hiddSyncAttrBase
 179 #define __IHidd_PixFmt      CDD(GfxBase)->hiddPixFmtAttrBase
 180 #define __IHidd_PlanarBM    CDD(GfxBase)->hiddPlanarBMAttrBase
 181 #define __IHidd_Gfx         CDD(GfxBase)->hiddGfxAttrBase
 182 #define __IHidd_FakeGfxHidd CDD(GfxBase)->hiddFakeGfxHiddAttrBase
 183 #define __IHidd_FakeFB      CDD(GfxBase)->hiddFakeFBAttrBase
 184
 185 /* Hashtable sizes. Must be powers of two */
 186 #define GFXASSOCIATE_HASHSIZE   8
 187 #define TFE_HASHTABSIZE         16
 188 #define DRIVERDATALIST_HASHSIZE 256
 189
 190 /* Internal GFXBase struct */
 191 struct GfxBase_intern
 192 {
 193     struct GfxBase              gfxbase;
 194
 195     ULONG                       displays;            /* Number of display drivers installed in the system        */
 196     struct common_driverdata    shared_driverdata;   /* Driver data shared between all monitors (allocated once) */
 197     struct SignalSemaphore      monitors_sema;       /* Monitor list semaphore                                   */
 198     struct SignalSemaphore      hashtab_sema;        /* hash_table arbitration semaphore                         */
 199     struct SignalSemaphore      view_sema;           /* ActiView arbitration semaphore                           */
 200
 201     /* TextFontExtension pool */
 202     struct tfe_hashnode         * tfe_hashtab[TFE_HASHTABSIZE];
 203     struct SignalSemaphore      tfe_hashtab_sema;
 204     struct SignalSemaphore      fontsem;
 205
 206 #if REGIONS_USE_MEMPOOL
 207     /* Regions pool */
 208     struct SignalSemaphore      regionsem;
 209     APTR                        regionpool;
 210     struct MinList              ChunkPoolList;
 211 #endif
 212
 213     /* GC driverdata pool */
 214     struct SignalSemaphore      driverdatasem;
 215     APTR                        driverdatapool;
 216     struct MinList              driverdatalist[DRIVERDATALIST_HASHSIZE];
 217
 218     /* Semaphores */
 219     struct SignalSemaphore      blit_sema;
 220
 221     /* Private library bases */
 222     struct Library             *CyberGfxBase;
 223     struct Library             *OOPBase;
 224     struct Library             *UtilityBase;
 225
 226     /* Private HIDD method bases */
 227     OOP_MethodID                HiddBitMapBase;
 228     OOP_MethodID                HiddColorMapBase;
 229     OOP_MethodID                HiddGCBase;
 230     OOP_MethodID                HiddGfxBase;
 231     OOP_MethodID                HiddPlanarBMBase;
 232 };
 233
 234
 235 /* Macros */
 236
 237 #define PrivGBase(x)            ((struct GfxBase_intern *)x)
 238 /* FIXME: Remove these #define xxxBase hacks
 239    Do not use this in new code !
 240 */
 241 #define HiddBitMapBase          (PrivGBase(GfxBase)->HiddBitMapBase)
 242 #define HiddColorMapBase        (PrivGBase(GfxBase)->HiddColorMapBase)
 243 #define HiddGCBase              (PrivGBase(GfxBase)->HiddGCBase)
 244 #define HiddGfxBase             (PrivGBase(GfxBase)->HiddGfxBase)
 245 #define HiddPlanarBMBase        (PrivGBase(GfxBase)->HiddPlanarBMBase)
 246
 247 /* This must be included before defining OOPBase */
 248 #include <hidd/graphics_inline.h>
 249
 250 /* struct Utilitybase is used in the following file so include it
 251    before defining Utilitybase
 252 */
 253 #include <proto/utility.h>
 254 #define CyberGfxBase            (PrivGBase(GfxBase)->CyberGfxBase)
 255 #define OOPBase                 (PrivGBase(GfxBase)->OOPBase)
 256 #define UtilityBase             (PrivGBase(GfxBase)->UtilityBase)
 257
 258 #define WIDTH_TO_BYTES(width)   ((( (width) + 15) & ~15) >> 3)
 259 #define WIDTH_TO_WORDS(width)   ((( (width) + 15) & ~15) >> 4)
 260
 261 #define XCOORD_TO_BYTEIDX( x )  (( x ) >> 3)
 262 #define XCOORD_TO_WORDIDX( x )  (( x ) >> 4)
 263
 264 #define COORD_TO_BYTEIDX(x, y, bytes_per_row)   \
 265                                 ( ( ((LONG)(y)) * (bytes_per_row)) + XCOORD_TO_BYTEIDX(x))
 266
 267 #define CHUNKY8_COORD_TO_BYTEIDX(x, y, bytes_per_row)   \
 268                                 ( ( ((LONG)(y)) * (bytes_per_row)) + (x) )
 269
 270 #define XCOORD_TO_MASK(x)       (128L >> ((x) & 0x07))
 271
 272 /* For vsprite sorting */
 273
 274 #define JOIN_XY_COORDS(x,y)     (LONG)( ( ((UWORD)(y)) << 16) + ( ( ((UWORD)(x)) + 0x8000 ) & 0xFFFF ) )
 275
 276 #define TFE(tfe)                (*(struct TextFontExtension**)&tfe)
 277
 278 #define TFE_MATCHWORD           0xDFE7 /* randomly invented */
 279
 280 /* Defines for flags in areainfo->FlagPtr */
 281
 282 #define AREAINFOFLAG_MOVE       0x00
 283 #define AREAINFOFLAG_DRAW       0x01
 284 #define AREAINFOFLAG_CLOSEDRAW  0x02
 285 #define AREAINFOFLAG_ELLIPSE    0x03
 286
 287 /* Forward declaration */
 288 struct ViewPort;
 289
 290 /* Hash index calculation */
 291 extern ULONG CalcHashIndex(IPTR n, UWORD size);
 292
 293 BOOL ObtainDriverData (struct RastPort * rp, struct GfxBase * GfxBase);
 294 void ReleaseDriverData (struct RastPort * rp, struct GfxBase * GfxBase);
 295 void KillDriverData (struct RastPort * rp, struct GfxBase * GfxBase);
 296
 297 /* a function needed by ClipBlit */
 298 void internal_ClipBlit(struct RastPort * srcRP,
 299                        LONG xSrc,
 300                        LONG ySrc,
 301                        struct RastPort * destRP,
 302                        LONG xDest,
 303                        LONG yDest,
 304                        LONG xSize,
 305                        LONG ySize,
 306                        UBYTE minterm,
 307                        struct GfxBase * GfxBase);
 308
 309 /* Driver prototypes */
 310
 311 typedef ULONG (*VIEW_FUNC)(struct HIDD_ViewPortData *vpd, struct View *v, struct monitor_driverdata *mdd, struct GfxBase *GfxBase);
 312
 313 extern ULONG driver_PrepareViewPorts(struct HIDD_ViewPortData *vpd, struct View *v, struct monitor_driverdata *mdd, struct GfxBase *GfxBase);
 314 extern ULONG driver_LoadViewPorts(struct HIDD_ViewPortData *vpd, struct View *v, struct monitor_driverdata *mdd, struct GfxBase *GfxBase);
 315 extern struct monitor_driverdata *driver_Setup(OOP_Object *gfxhidd, struct GfxBase *GfxBase);
 316 extern void driver_Expunge(struct monitor_driverdata *mdd, struct GfxBase *GfxBase);
 317 extern struct HIDD_ViewPortData *driver_FindViewPorts(struct View *view, struct monitor_driverdata *mdd, struct GfxBase *GfxBase);
 318 extern ULONG DoViewFunction(struct View *view, VIEW_FUNC fn, struct GfxBase *GfxBase);
 319
 320 /* functions in support.c */
 321 extern BOOL pattern_pen(struct RastPort *rp
 322         , LONG x, LONG y
 323         , ULONG apen, ULONG bpen
 324         , ULONG *pixval_ptr
 325         , struct GfxBase *GfxBase);
 326
 327 /* function for area opeartions */
 328 BOOL areafillpolygon(struct RastPort  * rp,
 329                      struct Rectangle * bounds,
 330                      UWORD              first_idx,
 331                      UWORD              last_idx,
 332                      ULONG              bytesperrow,
 333                      struct GfxBase   * GfxBase);
 334
 335 void areafillellipse(struct RastPort   * rp,
 336                      struct Rectangle  * bounds,
 337                      UWORD             * CurVctr,
 338                      ULONG               BytesPerRow,
 339                      struct GfxBase    * GfxBase);
 340
 341 void areaclosepolygon(struct AreaInfo *areainfo);
 342
 343 /* functions in color_support */
 344 ULONG color_distance(struct ColorMap * cm,
 345                      ULONG r,
 346                      ULONG g,
 347                      ULONG b,
 348                      ULONG index);
 349
 350 BOOL color_equal(struct ColorMap * cm,
 351                  ULONG r,
 352                  ULONG g,
 353                  ULONG b,
 354                  ULONG index);
 355
 356 VOID color_get(struct ColorMap *cm,
 357                 ULONG *r,
 358                 ULONG *g,
 359                 ULONG *b,
 360                 ULONG index);
 361
 362 void _DisposeRegionRectangleList
 363 (
 364     struct RegionRectangle *RR,
 365     struct GfxBase         *GfxBase
 366 );
 367
 368 struct RegionRectangle *_NewRegionRectangle
 369 (
 370     struct RegionRectangle **LastRectPtr,
 371     struct GfxBase *GfxBase
 372 );
 373
 374 BOOL _LinkRegionRectangleList
 375 (
 376     struct RegionRectangle  *src,
 377     struct RegionRectangle **dstptr,
 378     struct GfxBase          *GfxBase
 379 );
 380
 381 #if REGIONS_USE_POOL
 382 #   define GFX_ALLOC(Size)                                \
 383     ({                                                    \
 384         APTR Mem;                                         \
 385                                                           \
 386         ObtainSemaphore(&PrivGBase(GfxBase)->regionsem);  \
 387                                                           \
 388         Mem = AllocPooled                                 \
 389         (                                                 \
 390             PrivGBase(GfxBase)->regionpool,               \
 391             Size                                          \
 392         );                                                \
 393                                                           \
 394         ReleaseSemaphore(&PrivGBase(GfxBase)->regionsem); \
 395                                                           \
 396         Mem;                                              \
 397     })
 398
 399 #    define GFX_FREE(Mem, Size)                           \
 400      {                                                    \
 401         APTR Mem;                                         \
 402                                                           \
 403         ObtainSemaphore(&PrivGBase(GfxBase)->regionsem);  \
 404                                                           \
 405         FreePooled                                        \
 406         (                                                 \
 407             PrivGBase(GfxBase)->regionpool,               \
 408             Mem,                                          \
 409             size                                          \
 410         );                                                \
 411                                                           \
 412         ReleaseSemaphore(&PrivGBase(GfxBase)->regionsem); \
 413      }
 414 #else
 415 #    define GFX_ALLOC(Size)     AllocMem(Size, MEMF_ANY)
 416 #    define GFX_FREE(Mem, Size) FreeMem(Mem, Size)
 417 #endif
 418
 419 #define _NewRegionRectangleExtChunk() \
 420     __NewRegionRectangleExtChunk(GfxBase)
 421
 422 #define _DisposeRegionRectangleExtChunk(_chunk) \
 423     __DisposeRegionRectangleExtChunk(_chunk, GfxBase)
 424
 425 #define SIZECHUNKBUF 20
 426
 427 struct ChunkExt
 428 {
 429     struct RegionRectangleExtChunk  Chunk;
 430     struct ChunkPool               *Owner;
 431 };
 432
 433 struct ChunkPool
 434 {
 435     struct MinNode  Node;
 436     struct ChunkExt Chunks[SIZECHUNKBUF];
 437     struct MinList  ChunkList;
 438     LONG            NumChunkFree;
 439 };
 440
 441 void __DisposeRegionRectangleExtChunk
 442 (
 443     struct RegionRectangleExtChunk *Chunk,
 444     struct GfxBase *GfxBase
 445 );
 446
 447 struct BlitWaitQNode
 448 {
 449         struct MinNode node;
 450         struct Task *task;
 451 };
 452
 453 #endif /* GRAPHICS_INTERN_H */