MEMDRAW(2)                                             MEMDRAW(2)

          Memimage, Memdata, Memdrawparam, memimageinit, wordaddr,
          byteaddr, memimagemove, allocmemimage, allocmemimaged,
          readmemimage, creadmemimage, writememimage, freememimage,
          memsetchan, loadmemimage, cloadmemimage, unloadmemimage,
          memfillcolor, memarc, mempoly, memellipse, memfillpoly,
          memimageline, memimagedraw, drawclip, drawclipnorepl,
          memlinebbox, memlineendsize, allocmemsubfont,
          openmemsubfont, freememsubfont, memsubfontwidth,
          getmemdefont, memimagestring, hwdraw - drawing routines for
          memory-resident images

          #include <u.h>
          #include <libc.h>
          #include <draw.h>
          #include <memdraw.h>

          typedef struct Memdata
               ulong     *base;    /* allocated data pointer */
               uchar     *bdata;   /* first byte of actual data; word-aligned */
               int       ref;      /* number of Memimages using this data */
               void*     imref;    /* last image that pointed at this */
               int       allocd;   /* is this malloc'd? */
          } Memdata;

          enum {
               Frepl     = 1<<0,   /* is replicated */
               Fsimple   = 1<<1,   /* is 1x1 */
               Fgrey     = 1<<2,   /* is grey */
               Falpha    = 1<<3,   /* has explicit alpha */
               Fcmap     = 1<<4,   /* has cmap channel */
               Fbytes    = 1<<5,   /* has only 8-bit channels */

          typedef struct Memimage
               Rectangle r;        /* rectangle in data area, local coords */
               Rectangle clipr;    /* clipping region */
               int       depth;    /* number of bits of storage per pixel */
               int       nchan;    /* number of channels */
               ulong     chan;     /* channel descriptions */

               Memdata   *data;    /* pointer to data */
               int       zero;     /* data->bdata+zero==&byte containing (0,0) */
               ulong     width;    /* width in words of a single scan line */
               Memlayer  *layer;   /* nil if not a layer*/
               ulong     flags;

     Page 1                       Plan 9             (printed 7/22/24)

     MEMDRAW(2)                                             MEMDRAW(2)

          } Memimage;

          typedef struct Memdrawparam
               Memimage  *dst;
               Rectangle r;
               Memimage  *src;
               Rectangle sr;
               Memimage  *mask;
               Rectangle mr;
          } Memdrawparam;

          int         drawdebug;

          int         memimageinit(void)
          ulong*      wordaddr(Memimage *i, Point p)
          uchar*      byteaddr(Memimage *i, Point p)
          void        memimagemove(void *from, void *to)

          Memimage*   allocmemimage(Rectangle r, ulong chan)
          Memimage*   allocmemimaged(Rectangle r, ulong chan, Memdata *data)
          Memimage*   readmemimage(int fd)
          Memimage*   creadmemimage(int fd)
          int         writememimage(int fd, Memimage *i)
          void        freememimage(Memimage *i)
          int         memsetchan(Memimage*, ulong)

          int         loadmemimage(Memimage *i, Rectangle r,
                         uchar *buf, int nbuf)
          int         cloadmemimage(Memimage *i, Rectangle r,
                         uchar *buf, int nbuf)
          int         unloadmemimage(Memimage *i, Rectangle r,
                         uchar *buf, int nbuf)
          void        memfillcolor(Memimage *i, ulong color)

          void        memarc(Memimage *dst, Point c, int a, int b, int thick,
                         Memimage *src, Point sp, int alpha, int phi, Drawop op)
          void        mempoly(Memimage *dst, Point *p, int np, int end0,
                         int end1, int radius, Memimage *src, Point sp, Drawop op)
          void        memellipse(Memimage *dst, Point c, int a, int b,
                         int thick, Memimage *src, Point sp, Drawop op)
          void        memfillpoly(Memimage *dst, Point *p, int np, int wind,
                         Memimage *src, Point sp, Drawop op)
          void        memimageline(Memimage *dst, Point p0, Point p1, int end0,
                         int end1, int radius, Memimage *src, Point sp, Drawop op)
          void        memimagedraw(Memimage *dst, Rectangle r, Memimage *src,
                         Point sp, Memimage *mask, Point mp, Drawop op)

          int         drawclip(Memimage *dst, Rectangle *dr, Memimage *src,
                         Point *sp, Memimage *mask, Point *mp,
                         Rectangle *sr, Rectangle *mr)

     Page 2                       Plan 9             (printed 7/22/24)

     MEMDRAW(2)                                             MEMDRAW(2)

          int         drawclipnorepl(Memimage *dst, Rectangle *dr, Memimage *src,
                         Point *sp, Memimage *mask, Point *mp,
                         Rectangle *sr, Rectangle *mr)
          Rectangle   memlinebbox(Point p0, Point p1, int end0, int end1,
                         int radius)
          int         memlineendsize(int end)

          Memsubfont* allocmemsubfont(char *name, int n, int height,
                         int ascent, Fontchar *info, Memimage *i)
          Memsubfont* openmemsubfont(char *name)
          void        freememsubfont(Memsubfont *f)
          Point       memsubfontwidth(Memsubfont *f, char *s)
          Memsubfont* getmemdefont(void)
          Point       memimagestring(Memimage *dst, Point p, Memimage *color,
                          Point cp, Memsubfont *f, char *cs)

          int         hwdraw(Memdrawparam *param)

          The Memimage type defines memory-resident rectangular pic-
          tures and the methods to draw upon them; Memimages differ
          from Images (see draw(2)) in that they are manipulated
          directly in user memory rather than by RPCs to the /dev/draw
          hierarchy.  The memdraw library is the basis for the kernel
          draw(3) driver and also used by a number of programs that
          must manipulate images without a display.

          The r, clipr, depth, nchan, and chan structure elements are
          identical to the ones of the same name in the Image struc-

          The flags element of the Memimage structure holds a number
          of bits of information about the image.  In particular, it
          subsumes the purpose of the repl element of Image struc-

          Memimageinit initializes various static data that the
          library depends on, as well as the replicated solid color
          images memopaque, memtransparent, memblack, and memwhite.
          It should be called before referring to any of these images
          and before calling any of the other library functions. It
          returns non-zero on error.

          Each Memimage points at a Memdata structure that in turn
          points at the actual pixel data for the image.  This allows
          multiple images to be associated with the same Memdata.  The
          first word of the data pointed at by the base element of
          Memdata points back at the Memdata structure, so that the
          memory allocator (see pool(2)) can compact image memory
          using memimagemove.

          Because images can have different coordinate systems, the

     Page 3                       Plan 9             (printed 7/22/24)

     MEMDRAW(2)                                             MEMDRAW(2)

          zero element of the Memimage structure contains the offset
          that must be added to the bdata element of the corresponding
          Memdata structure in order to yield a pointer to the data
          for the pixel (0,0).  Adding width machine words to this
          pointer moves it down one scan line.  The depth element can
          be used to determine how to move the pointer horizontally.
          Note that this method works even for images whose rectangles
          do not include the origin, although one should only derefer-
          ence pointers corresponding to pixels within the image rect-
          angle.  Wordaddr and byteaddr perform these calculations,
          returning pointers to the word and byte, respectively, that
          contain the beginning of the data for a given pixel.

          Allocmemimage allocates images with a given rectangle and
          channel descriptor (see strtochan in graphics(2)), creating
          a fresh Memdata structure and associated storage.
          Allocmemimaged is similar but uses the supplied Memdata
          structure rather than a new one.  The readmemimage function
          reads an uncompressed bitmap from the given file descriptor,
          while creadmemimage reads a compressed bitmap.
          Writememimage writes a compressed representation of i to
          file descriptor fd. For more on bitmap formats, see
          image(6). Freememimage frees images returned by any of these
          routines.  The Memimage structure contains some tables that
          are used to store precomputed values depending on the chan-
          nel descriptor.  Memsetchan updates the chan element of the
          structure as well as these tables, returning -1 if passed a
          bad channel descriptor.

          Loadmemimage and cloadmemimage replace the pixel data for a
          given rectangle of an image with the given buffer of uncom-
          pressed or compressed data, respectively.  When calling
          cloadmemimage, the buffer must contain an integral number of
          compressed chunks of data that exactly cover the rectangle.
          Unloadmemimage retrieves the uncompressed pixel data for a
          given rectangle of an image.  All three return the number of
          bytes consumed on success, and -1 in case of an error.

          Memfillcolor fills an image with the given color, a 32-bit
          number as described in color(2).

          Memarc, mempoly, memellipse, memfillpoly, memimageline, and
          memimagedraw are identical to the arc, poly, ellipse,
          fillpoly, line, and gendraw, routines described in draw(2),
          except that they operate on Memimages rather than Images.
          Similarly, allocmemsubfont, openmemsubfont, freememsubfont,
          memsubfontwidth, getmemdefont, and memimagestring are the
          Memimage analogues of allocsubfont, openfont, freesubfont,
          strsubfontwidth, getdefont, and string (see subfont(2) and
          graphics(2)), except that they operate only on Memsubfonts
          rather than Fonts.

     Page 4                       Plan 9             (printed 7/22/24)

     MEMDRAW(2)                                             MEMDRAW(2)

          Drawclip takes the images involved in a draw operation,
          together with the destination rectangle dr and source and
          mask alignment points sp and mp, and clips them according to
          the clipping rectangles of the images involved.  It also
          fills in the rectangles sr and mr with rectangles congruent
          to the returned destination rectangle but translated so the
          upper left corners are the returned sp and mp.
          Drawclipnorepl does the same as drawclip but avoids clamping
          sp and mr within the image rectangle of source and mask when
          replicated.  Drawclip and drawclipnorepl return zero when
          the clipped rectangle is empty.  Memlinebbox returns a con-
          servative bounding box containing a line between two points
          with given end styles and radius.  Memlineendsize calculates
          the extra length added to a line by attaching an end of a
          given style.

          The hwdraw function is a no-op stub that may be overridden
          by clients of the library.  Hwdraw is called at each call to
          memimagedraw with the current request's parameters.  If it
          can satisfy the request, it should do so and return 1.  If
          it cannot satisfy the request, it should return 0.  This
          allows (for instance) the kernel to take advantage of hard-
          ware acceleration.


          addpt(2), color(2), draw(2), graphics(2), memlayer(2),
          stringsize(2), subfont(2), color(6), utf(6)

          Memimagestring is unusual in using a subfont rather than a
          font, and in having no parameter to align the source.

     Page 5                       Plan 9             (printed 7/22/24)