Suggestions for optimization

StanEd

Hi guys,

I just needed an 'is_same_bitmap' function (compares only the image data of the bitmap and ignores alpha [suitable for the purpose I had in mind])

I wrote the following which when using memory bitmaps is perfectly fast for my purposes (it's a one off conversion job rather than a critical run-time process) but I'm always keen to know of improvements I can make to code. So, here is my code and I'd welcome any suggestions for optimization or how you might write the same function.

#SelectExpand
  1bool al_is_same_bitmap(ALLEGRO_BITMAP *img1, ALLEGRO_BITMAP *img2)
  2{
  if(al_get_bitmap_width(img1) != al_get_bitmap_width(img2) ||
     al_get_bitmap_height(img1) != al_get_bitmap_height(img2))
     {
         // Simple check, if they are not the same size they can't be the same.
         return false;
     }
  9
  int x;
  int y;
  ALLEGRO_COLOR colour1;
  ALLEGRO_COLOR colour2;
  unsigned char r[2];
  unsigned char g[2];
  unsigned char b[2];
 17
  for(y = 0; y < al_get_bitmap_height(img1); y += 1)
  {
      for(x = 0; x < al_get_bitmap_width(img1); x += 1)
      {
          colour1 = al_get_pixel(img1, x, y);
          al_unmap_rgb(colour1, &r[0], &g[0], &b[0]);
          colour2 = al_get_pixel(img2, x, y);
          al_unmap_rgb(colour2, &r[1], &g[1], &b[1]);
          if(r[0] != r[1] || g[0] != g[1] || b[0] != b[1])
          {
              return false;
          }
      }
  }
  return true;
 33}

Thank you,

Stan

SiegeLord

You can speed things up by locking the bitmaps. Also, if you do lock them you can compare them line-by-line like so:

#SelectExpand
  1ALLEGRO_LOCKED_REGION *lr1 = al_lock_bitmap(b1, al_get_bitmap_format(b1), ALLEGRO_LOCK_READONLY);
  2ALLEGRO_LOCKED_REGION *lr2 = al_lock_bitmap(b2, al_get_bitmap_format(b1), ALLEGRO_LOCK_READONLY);
  3
  4for (int y = 0; y < al_get_bitmap_height(b1); y++) {
  5  if (memcmp((char*)lr1->data + lr1->pitch * y,
  6             (char*)lr2->data + lr2->pitch * y,
  7             lr1->pixel_size * al_get_bitmap_width(b1)) != 0) {
  8    al_unlock_bitmap(b1);
  9    al_unlock_bitmap(b2);
 10    return false;
 11  }
 12}
 13
 14al_unlock_bitmap(b1);
 15al_unlock_bitmap(b2);
 16
 17return true;

Chris Katko

How often do you do this twice? That is, the same bitmap will be checked twice? And how often are the bitmaps changed? Because it might be useful to just calculate hashes for them (going pixel by pixel once per bitmap) and then compare the hashes.

Thread #617177. Printed from Allegro.cc