home *** CD-ROM | disk | FTP | other *** search
/ The Pier Shareware 6 / The_Pier_Shareware_Number_6_(The_Pier_Exchange)_(1995).iso / 035 / modex32.zip / MKALIGN.C < prev    next >
C/C++ Source or Header  |  1994-09-03  |  3KB  |  79 lines
  1. /* Generates all four possible mode X image/mask alignments, stores image 
  2. alignments in display memory, allocates memory for and generates mask 
  3. alignments, and fills out an AlignedMaskedImage structure. Image and mask must 
  4. both be in byte-per-pixel form, and must both be of width ImageWidth. Mask 
  5. maps isomorphically (one to one) onto image, with each 0-byte in mask masking
  6. off corresponding image pixel (causing it not to be drawn), and each non-0-byte
  7. allowing corresponding image pixel to be drawn. Returns 0 if failure, or # of 
  8. display memory addresses (4-pixel sets) used if success. For simplicity, 
  9. allocated memory is not deallocated in case of failure. Compiled with 
  10. Borland C++ 2.0 in C compilation mode. */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include "maskim.h"
  15.  
  16. extern void CopySystemToScreenX(int, int, int, int, int, int, char *,
  17.    unsigned int, int, int);
  18.  
  19. unsigned int CreateAlignedMaskedImage(MaskedImage * ImageToSet,
  20.    unsigned int DispMemStart, char * Image, int ImageWidth,
  21.    int ImageHeight, char * Mask)
  22. {
  23.    int Align, ScanLine, BitNum, Size, TempImageWidth;
  24.    unsigned char MaskTemp;
  25.    unsigned int DispMemOffset = DispMemStart;
  26.    AlignedMaskedImage *WorkingAMImage;
  27.    char *NewMaskPtr, *OldMaskPtr;
  28.  
  29.    /* Generate each of the four alignments in turn */
  30.    for (Align = 0; Align < 4; Align++) {
  31.  
  32.       /* Allocate space for the AlignedMaskedImage struct for this
  33.          alignment */
  34.       if ((WorkingAMImage = ImageToSet->Alignments[Align] =
  35.             malloc(sizeof(AlignedMaskedImage))) == NULL)
  36.          return 0;
  37.  
  38.       WorkingAMImage->ImageWidth =
  39.             (ImageWidth + Align + 3) / 4; /* width in 4-pixel sets */
  40.  
  41.       WorkingAMImage->ImagePtr = DispMemOffset; /* image dest */
  42.  
  43.       /* Download this alignment of the image */
  44.       CopySystemToScreenX(0, 0, ImageWidth, ImageHeight, Align, 0,
  45.             Image, DispMemOffset, ImageWidth,
  46.             WorkingAMImage->ImageWidth * 4);
  47.  
  48.       /* Calculate the number of bytes needed to store the mask in
  49.          nibble (Map Mask-ready) form, then allocate that space */
  50.       Size = WorkingAMImage->ImageWidth * ImageHeight;
  51.  
  52.       if ((WorkingAMImage->MaskPtr = malloc(Size)) == NULL)
  53.          return 0;
  54.  
  55.       /* Generate this nibble oriented (Map Mask-ready) alignment of
  56.          the mask, one scan line at a time */
  57.       OldMaskPtr = Mask;
  58.       NewMaskPtr = WorkingAMImage->MaskPtr;
  59.       for (ScanLine = 0; ScanLine < ImageHeight; ScanLine++) {
  60.          BitNum = Align;
  61.          MaskTemp = 0;
  62.          TempImageWidth = ImageWidth;
  63.          do {
  64.             /* Set the mask bit for next pixel according to its alignment */
  65.             MaskTemp |= (*OldMaskPtr++ != 0) << BitNum;
  66.             if (++BitNum > 3) {
  67.                *NewMaskPtr++ = MaskTemp;
  68.                MaskTemp = BitNum = 0;
  69.             }
  70.          } while (--TempImageWidth);
  71.          /* Set any partial final mask on this scan line */
  72.          if (BitNum != 0) *NewMaskPtr++ = MaskTemp;
  73.       }
  74.       DispMemOffset += Size; /* mark off the space we just used */
  75.    }
  76.    return DispMemOffset - DispMemStart;
  77. }
  78.  
  79.