git.sur5r.net Git - cc65/blob - src/sp65/bitmap.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 bitmap.c                                  */
   4 /*                                                                           */
   5 /*         Bitmap definition for the sp65 sprite and bitmap utility          */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2012,      Ullrich von Bassewitz                                      */
  10 /*                Roemerstrasse 52                                           */
  11 /*                D-70794 Filderstadt                                        */
  12 /* EMail:         uz@cc65.org                                                */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 /* common */
  37 #include "check.h"
  38 #include "xmalloc.h"
  39
  40 /* sp65 */
  41 #include "bitmap.h"
  42 #include "error.h"
  43
  44
  45
  46 /*****************************************************************************/
  47 /*                                   Code                                    */
  48 /*****************************************************************************/
  49
  50
  51
  52 Bitmap* NewBitmap (unsigned Width, unsigned Height)
  53 /* Create a new bitmap. The type is set to unknown and the palette to NULL */
  54 {
  55     Bitmap* B;
  56
  57     /* Calculate the size of the bitmap in pixels */
  58     unsigned long Size = (unsigned long) Width * Height;
  59
  60     /* Some safety checks */
  61     PRECONDITION (Size > 0 && Size <= BM_MAX_SIZE);
  62
  63     /* Allocate memory */
  64     B = xmalloc (sizeof (*B) + (Size - 1) * sizeof (B->Data[0]));
  65
  66     /* Initialize the data */
  67     B->Type     = bmUnknown;
  68     B->Name     = EmptyStrBuf;
  69     B->Tag      = 0;
  70     B->Width    = Width;
  71     B->Height   = Height;
  72     B->Pal      = 0;
  73
  74     /* Return the bitmap */
  75     return B;
  76 }
  77
  78
  79
  80 void FreeBitmap (Bitmap* B)
  81 /* Free a dynamically allocated bitmap */
  82 {
  83     /* Free the format specific data, the palette and then the bitmap */
  84     xfree (B->Tag);
  85     xfree (B->Pal);
  86     xfree(B);
  87 }
  88
  89
  90
  91 int ValidBitmapSize (unsigned Width, unsigned Height)
  92 /* Return true if this is a valid size for a bitmap */
  93 {
  94     /* Calculate the size of the bitmap in pixels */
  95     unsigned long Size = (unsigned long) Width * Height;
  96
  97     /* Check the size */
  98     return (Size > 0 && Size <= BM_MAX_SIZE);
  99 }
 100
 101
 102
 103 Bitmap* SliceBitmap (const Bitmap* O, unsigned OrigX, unsigned OrigY,
 104                      unsigned Width, unsigned Height)
 105 /* Create a slice of the given bitmap. The slice starts at position X/Y of
 106  * the original and has the given width and height. Location 0/0 is at the
 107  * upper left corner.
 108  */
 109 {
 110     Bitmap*  B;
 111     unsigned Y;
 112
 113
 114     /* Check the coordinates and size */
 115     PRECONDITION (OrigX != 0 && OrigY != 0 &&
 116                   OrigX + Width <= O->Width &&
 117                   OrigY + Height <= O->Height);
 118
 119     /* Create a new bitmap with the given size */
 120     B = NewBitmap (Width, Height);
 121
 122     /* Copy fields from the original */
 123     B->Type = O->Type;
 124     if (SB_GetLen (&O->Name) > 0) {
 125         SB_CopyStr (&B->Name, "Slice of ");
 126         SB_Append (&B->Name, &O->Name);
 127     }
 128     B->Pal = DupPalette (O->Pal);
 129
 130     /* Copy the pixel data */
 131     for (Y = 0; Y < Height; ++Y) {
 132         memcpy (B->Data + Y * B->Width,
 133                 O->Data + (OrigY + Y) * O->Width + OrigX,
 134                 Width * sizeof (O->Data[0]));
 135     }
 136
 137     /* Return the slice */
 138     return B;
 139 }
 140
 141
 142
 143 Color GetPixelColor (const Bitmap* B, unsigned X, unsigned Y)
 144 /* Get the color for a given pixel. For indexed bitmaps, the palette entry
 145  * is returned.
 146  */
 147 {
 148     /* Get the pixel at the given coordinates */
 149     Pixel P = GetPixel (B, X, Y);
 150
 151     /* If the bitmap has a palette, return the color from the palette. For
 152      * simplicity, we will only check the palette, not the type.
 153      */
 154     if (B->Pal) {
 155         if (P.Index >= B->Pal->Count) {
 156             /* Palette index is invalid */
 157             Error ("Invalid palette index %u at position %u/%u of \"%*s\"",
 158                    P.Index, X, Y, SB_GetLen (&B->Name),
 159                    SB_GetConstBuf (&B->Name));
 160         }
 161         return B->Pal->Entries[P.Index];
 162     } else {
 163         return P.C;
 164     }
 165 }
 166
 167
 168
 169 Pixel GetPixel (const Bitmap* B, unsigned X, unsigned Y)
 170 /* Return a pixel from the bitmap. The returned value may either be a color
 171  * or a palette index, depending on the type of the bitmap.
 172  */
 173 {
 174     /* Check the coordinates */
 175     PRECONDITION (X < B->Width && Y < B->Height);
 176
 177     /* Return the pixel */
 178     return B->Data[Y * B->Width + X];
 179 }
 180
 181
 182