Hey guys. I'm working with a bitmap image from an old piece of software (2001-ish). The image is a tile sheet of tiles used in the game. I'm creating a map editor for the game, so I need to read and write the map files in the exact same format.

In the map files, tiles are numerically ordered starting from one, based on the order they appear in the sheet (tiles are 100x100 pixels). However, not all spots in the sheet contain images. In some cases, the spot is filled in with a single color (which the program uses as transparent on its tile). In cases where a tile is absent, that spot is skipped for the purposes of assigning numbers to the tiles.

So I need a way to do one of two things:

1) Test if a bitmap is a solid color.

or

2) Test if two bitmaps are equal.

I couldn't find a function for either in allegro, and I was curious if I missed it. Worse comes to worse, I'll write the function if it doesn't exist, but prefer not to do that if I can avoid it.

Or am I just missing a totally obvious solution? I kinda feel like I am.

You'll have to do both yourself. The first is easy, and the second is only slightly harder.

1)

int is_bitmap_solid_color(BITMAP* bmp , int color) {
   if (!bmp) {return 0;}
   for (int y = 0 ; y < bmp->h ; ++y) {
      for (int x = 0 ; x < bmp->w ; ++x) {
         if (color != getpixel(bmp , x , y)) {return 0;}
      }
   }
   return 1;
}

2)

int are_bitmaps_equal(BITMAP* b1 , BITMAP* b2) {
   if (!b1 || !b2) {return 0;}
   if (b1 == b2) {return 1;}
   if (bitmap_color_depth(b1) != bitmap_color_depth(b2)) {return 0;}
   if ((b1->w != b2->w) || (b1->h != b2->h)) {return 0;}
   for (int y = 0 ; y < b1->h ; ++y) {
      for (int x = 0 ; x < b1->w ; ++x) {
         if (getpixel(b1,x,y) != getpixel(b2,x,y)) {return 0;}
      }
   }
   return 1;
}

I just wrote them myself, since they only took a couple minutes.

You didn't specify A4 or A5, so I just used A4.

Using A5 will be somewhat different :
1)

int is_bitmap_solid_color(ALLEGRO_BITMAP* bmp , ALLEGRO_COLOR color) {
   if (!bmp) {return 0;}
   al_lock_bitmap(bmp , al_get_bitmap_format(bmp) , ALLEGRO_LOCK_READONLY);
   for (int y = 0 ; y < al_get_bitmap_height(bmp) ; ++y) {
      for (int x = 0 ; x < al_get_bitmap_width(bmp) ; ++x) {
         if (color != al_get_pixel(bmp , x , y)) {
            al_unlock_bitmap(bmp);
            return 0;
         }
      }
   }
   al_unlock_bitmap(bmp);
   return 1;
}

2)

A5 takes more code.

With allegro 4 bitmaps, you could use memcmp() on each bmp->line[y] to speed up the comparison. It would also avoid the bit-shifting that occurs in al_get_pixel() to re-order the R G B components.

Looks like ML already posted some code for fast image comparison:
http://www.allegro.cc/forums/thread/606084/898790#target
In the linked post he compared only edges, ie. lines on top, bottom, left and right.
The critical code is:

  // Do once
  b1_lock = al_lock_bitmap(b1, ALLEGRO_PIXEL_FORMAT_ARGB_8888, ALLEGRO_LOCK_READONLY);
  b2_lock = al_lock_bitmap(b2, ALLEGRO_PIXEL_FORMAT_ARGB_8888, ALLEGRO_LOCK_READONLY);  
  b1_data = b1_lock->data;
  b2_data = b2_lock->data;
  // Do for each y line of bitmaps:
  if (memcmp(
      (uint8_t*)&b1_data[x1] + b1_lock->pitch * (y1+y), 
      (uint8_t*)&b2_data[x2] + b2_lock->pitch * (y2+y),
          width)) {...} // is different

(with x1,y1 the coordinates of the block in bitmap b1, and x2,y2 the coordinates in bitmap b2)