Allegro5 Save bitmap to byte array

no-reply@allegro.cc (Kevin NO) — Fri, 16 May 2014 08:03:30 +0000

Hello everyone,
I am looking to convert a sub bitmap to a byte array to save into an SQLite database. I have done it in .NET but I am having a lot of trouble doing it in C++. What I have now looks something like this:

size_t *size = new size_t();
ALLEGRO_FILE *SavFil = malloc(size);
al_save_bitmap_f(SavFil, ".bmp", al_create_sub_bitmap(World, x, y, 16, 16));

but that is totally wrong. How do I access the byte info inside of ALLEGRO_FILE?
do I need to use ALLEGRO_FILE_INTERFACE to access that information?
Thanks for the help!

no-reply@allegro.cc (beoran) — Fri, 16 May 2014 10:41:42 +0000

You will need to use the memfile addon and al_open_memfile()

no-reply@allegro.cc (Kevin NO) — Sat, 17 May 2014 08:33:12 +0000

Thanks for the quick reply! I am trying to use the memfile, here is what I have:

SubBmp = al_create_sub_bitmap(World, x, y, 16, 16);
al_draw_bitmap(SubBmp, 0,0,NULL);
al_flip_display();

data_size = al_get_bitmap_width(SubBmp) * al_get_bitmap_height(SubBmp) * al_get_pixel_size(al_get_bitmap_format(SubBmp));

ALLEGRO_BITMAP *bmp = al_create_sub_bitmap(World, x, y, 16, 16);
data = (char*)calloc(1, data_size);
ALLEGRO_FILE *memfile = al_open_memfile(buffer, data_size, "w+b");
bool result = al_save_bitmap_f(memfile, ".bmp", SubBmp);
size_t bytes = al_fread(memfile, buffer, data_size);

//Test if buffer has bitmap array
FILE *fp;
fp=fopen("c:\\test.bin", "wb");
fwrite(buffer, sizeof(buffer[0]), sizeof(buffer)/sizeof(buffer[0]), fp);

al_fclose(memfile);
free(data);

Still nothing in the buffer, or at lest i don't think there is.
This also seems like the wrong way of doing it. If you guys could help me on the right path I would really appreciate it. Thanks

no-reply@allegro.cc (Edgar Reynaldo) — Sat, 17 May 2014 09:34:16 +0000

I wouldn't do it quite that way. It would be easier to lock the bitmap and read the data directly.

Ex :

#SelectExpand
  1unsigned char* BitmapBytes(ALLEGRO_BITMAP* bmp , int* size_store) {
  2   int size = al_get_bitmap_width(bmp)*al_get_bitmap_height(bmp)*4;
  3   unsigned char* buffer = malloc(size);
  4   if (buffer) {
  5      *size_store = size;
  6   } else {
  7      *size_store = 0;
  8      return 0;
  9   }
 10
 11   ALLEGRO_LOCKED_REGION* lock = al_lock_bitmap(bmp , ALLEGRO_PIXEL_FORMAT_RGBA_8888 , ALLEGRO_LOCK_READONLY);
 12
 13   for (unsigned int y = 0 ; y < al_get_bitmap_height(bmp) ; ++y) {
 14      unsigned char* dat = (unsigned char*)lock->data + 4*y*lock->pitch;
 15      memcpy(buffer + 4*y*al_get_bitmap_width(bmp) , dat , 4*al_get_bitmap_width(bmp));
 16   } 
 17
 18   al_unlock_bitmap(bmp);
 19
 20   return buffer;
 21}

Untested, but you get the idea. The bitmap is locked using RGBA_8888 (allegro will perform necessary conversions for you), and then a simple memcpy copies the memory into the newly allocated buffer and the function returns the buffer and stores the size in the int pointer provided to the function.

You can use code goes here... tags to show your code. Makes it easier to read.

no-reply@allegro.cc (Thomas Fjellstrom) — Sat, 17 May 2014 09:46:19 +0000

Edgar Reynaldo said:

Depends if he wants the actual bitmap headers or not.

no-reply@allegro.cc (Edgar Reynaldo) — Sat, 17 May 2014 09:58:42 +0000

Well, in that case I would just save the bitmap to a temporary file on the hard drive and not mess around with a memfile. It would be much easier to get a fix on the actual size of the bitmap file.

no-reply@allegro.cc (Thomas Fjellstrom) — Sat, 17 May 2014 10:14:31 +0000

Depends if he wants it to hit the disk or not

no-reply@allegro.cc (Edgar Reynaldo) — Sat, 17 May 2014 17:10:05 +0000

The point I was trying to make is that he has to know the exact layout of the file if he wants the headers and he is going to use a memfile, otherwise he doesn't know the exact size of the buffer he needs. That's why I suggested saving to disk.

no-reply@allegro.cc (beoran) — Sat, 17 May 2014 23:32:45 +0000

In the code above, where does buffer come from? you shoyld use data to initailze the memfile and save that, I think. Also , you seem to draw to the wrong bitmap. It's hard to say without the complete code. Could you psot a complete, compilable example of what you're trying to do?

no-reply@allegro.cc (Kevin NO) — Mon, 19 May 2014 09:10:34 +0000

Hello, What I am trying to do is read a Large bitmap into a database.
It should be easy, but I am having more trouble than I was thinking it was.
here is my full code:

#SelectExpand
   1/*
   2#include 
   3#ifdef _MSC_VER
   4#pragma comment ( linker, "/SUBSYSTEM:CONSOLE")
   5#endif #define ALLEGRO_USE_CONSOLE
   6#include 
   7#include 
   8
   9int main(void)
  10{
ALLEGRO_FILE *memfile;
char *data;
int i;
const int data_size = 1024;
char buffer[50];
if (!al_init())
{
  //abort_example("Could not init Allegro.\n");
}
data = (char*)calloc(1, data_size);
if (!data) return 1;
printf("Creating memfile\n");
memfile = al_open_memfile(data, data_size, "rw");
if (!memfile)
{
  printf("Error opening memfile :(\n");
  goto Error;
}
printf("Writing data to memfile\n");
for (i = 0; i < data_size/4; i++)
{
  if (al_fwrite32le(memfile, i) < 4)
  {
    printf("Failed to write %i to memfile\n", i);
    goto Error;
  }
}
al_fseek(memfile, 0, ALLEGRO_SEEK_SET);
printf("Reading and testing data from memfile\n");
for (i = 0; i < data_size/4; i++)
{
  int32_t ret = al_fread32le(memfile);
  if (ret != i || al_feof(memfile))
  {
    printf("Item %i failed to verify, got %i\n", i, ret);
    goto Error;
  }
}
if (al_feof(memfile))
{
  printf("EOF indicator prematurely set!\n");
  goto Error;
}
al_fseek(memfile, 0, ALLEGRO_SEEK_SET);
for (i = 0; al_fungetc(memfile, i) != EOF; ++i) { }
printf("Length of ungetc buffer: %d\n", i);
if (al_ftell(memfile) != -i)
{
  printf("Current position is not correct. Expected -%d, but got %d\n", i, (int) al_ftell(memfile));
  goto Error;
}
while (i--)
{
  if (i != al_fgetc(memfile))
  {
    printf("Failed to verify ungetc data.\n");
    goto Error;
  }
}
if (al_ftell(memfile) != 0)
{
  printf("Current position is not correct after reading back the ungetc buffer\n");
  printf("Expected 0, but got %d\n", (int) al_ftell(memfile));
  goto Error;
}
al_fputs(memfile, "legro rocks!");
al_fseek(memfile, 0, ALLEGRO_SEEK_SET);
al_fungetc(memfile, 'l');
al_fungetc(memfile, 'A');
al_fgets(memfile, buffer, 15);
if (strcmp(buffer, "Allegro rocks!"))
{
  printf("Expected to see 'Allegro rocks!' but got '%s' instead.\n", buffer);
  printf("(Maybe the ungetc buffer isn't big enough.)\n");
  goto Error;
}
printf("Done.\n");
al_fclose(memfile);
free(data);
return 0;
  91Error:
al_fclose(memfile);
free(data);
return 1;
  95}*/ 
  96
  97#pragma region MyRegion
  98#include 
  99#include 
 100#include 
 101#include "sqlite3.h"
 102#include 
 103#include 
 104#include 
 105#include 
 106#include 
 107#include "allegro5/allegro_native_dialog.h"
 108#include 
 109
 110
 111
 112static int callback(void *NotUsed, int argc, char **argv, char **azColName){
 int i;
 for(i=0; i<argc; i++){
    printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
 }
 printf("\n");
 return 0;
 119}
 120
 121unsigned char* BitmapBytes(ALLEGRO_BITMAP* bmp , int* size_store)
 122{
int size = al_get_bitmap_width(bmp)*al_get_bitmap_height(bmp)*4;
unsigned char* buffer = (unsigned char*)malloc(size);
if (buffer)
{
  *size_store = size;
}
else
{
  *size_store = 0;
  return 0;
}
ALLEGRO_LOCKED_REGION* lock = al_lock_bitmap(bmp , ALLEGRO_PIXEL_FORMAT_RGBA_8888 , ALLEGRO_LOCK_READONLY);
for (unsigned int y = 0 ; y < al_get_bitmap_height(bmp); ++y)
{
  unsigned char* dat = (unsigned char*)lock->data + 4*y*lock->pitch;
  memcpy(buffer + 4*y*al_get_bitmap_width(bmp) , dat , 4*al_get_bitmap_width(bmp));
}
al_unlock_bitmap(bmp);
return buffer;
 142}
 143
 144int main(int argc, char **argv){
 145
al_init();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
 150
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
event_queue = al_create_event_queue();
 153
std::vector<ALLEGRO_BITMAP*> Bitmaps;
 155
ALLEGRO_DISPLAY *display = al_create_display(640,480);
al_register_event_source(event_queue, al_get_display_event_source(display));
ALLEGRO_FONT *font = al_load_ttf_font("C:\\Users\\Kevin\\Desktop\\Programing\\BitmapToSqliteConverter\\Debug\\arial.ttf",24,0 );
 159
//al_clear_to_color(al_map_rgb(50,10,70));

 162
 163
ALLEGRO_BITMAP* World = NULL;
World = al_load_bitmap("C:/Users/Kevin/Desktop/Programing/BitmapToSqliteConverter/Debug/Island.bmp");
if(!World) {
  printf("Error loading hello.bmp\n");
  return 1;
}
 170
sqlite3 *db;
 char *zErrMsg = 0;
 int rc;
 rc = sqlite3_open("C:\\Users\\Kevin\\Desktop\\Programing\\mov\\movDB", &db);
 /* Open database */
       if( rc ){
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        exit(0);
       }else{
        fprintf(stderr, "Opened database successfully\n");
       }
       const char* sql;
 183
char fileName[10];
int count = 0;
 186
ALLEGRO_FILE *memfile;
ALLEGRO_BITMAP *SubBmp;
char data[5];
int data_size;
unsigned char *buffer;
 192
void *fileBuffer;
void *graphicBuffer;
int length = 16;
 196
for (int y = 10; y < al_get_bitmap_height(World); y = y + 16)
{
  for (int x = 0; x < al_get_bitmap_width(World); x = x + 16)
  {
    SubBmp = al_create_sub_bitmap(World, x, y, 16, 16);
    //buffer = BitmapBytes(SubBmp, &length);
    count++;
    itoa(count,data,10);
    al_save_bitmap(strcat(data,".bmp"),SubBmp);
    
  }
}
return 0;
 210}  
 211#pragma endregion

no-reply@allegro.cc (beoran) — Mon, 19 May 2014 16:20:26 +0000

Hmmm, your coee seems to be missing the point. I have attached an example that cuts up a bitmap and saves it to files using the memfile addon. However, I think you could adapt without too much effort to saving to sqlite using the real_size and buffer.

Here is the code repeated:

#SelectExpand
   1#include 
   2#include 
   3#include 
   4#include 
   5
   6
   7#define DISPLAY_W 640
   8#define DISPLAY_H 480
   9
  10#define SKIP_W 16
  11#define SKIP_H 16
  12
  13void display_bitmap(ALLEGRO_BITMAP * bmp, int x, int y, double delay) {
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_bitmap(bmp, (double)x, (double)y, 0);
al_flip_display();
al_rest(delay);
  18}
  19
  20bool save_sub_bitmap(ALLEGRO_BITMAP * sub, 
                   int x, int y, int slice_w, int slice_h, 
                   const char * prefix) {
int size;
void * buffer;
int real_size;
ALLEGRO_FILE * memfile;
      
if(!sub) {
  fprintf(stderr, "Could not create sub bitmap!\n");
  return false;
}
/* Allocate a buffer that should always be too big.*/
size      = slice_w * slice_h * 4 * 2;
buffer    = calloc(size, 1);
real_size = 0;
if(!buffer) {
  fprintf(stderr, "Could not allocate buffer!\n");
  return false;
}

/* Open memfile. */
memfile = al_open_memfile(buffer, size, "rw");
if(!memfile) {
  fprintf(stderr, "Failed to open memfile!\n"); 
} else {
  /* save the bitmap into the memfile. */
  al_save_bitmap_f(memfile, ".bmp", sub);
  /* Get the real size of the bitmap. */
  real_size = al_ftell(memfile);
  if(real_size < 1) {
    fprintf(stderr, "Real size is too small!\n");
  } else {
    /* now, buffer contains the correct bitmap data. Save that to a file
     * (but if could be stored into sqlite as well, if needed). */
    FILE * output;
    char filename[255];
    sprintf(filename, "%.16s_%d_%d.bmp\0", prefix, (int)(x / slice_w) + 1, (int)(y/slice_h) + 1);
    output = fopen(filename, "w");
    if(!output) {
      fprintf(stderr, "Could not open output file!\n");
    } else {
      fwrite(buffer, size, 1, output);
      fclose(output);
    }
 }
 al_fclose(memfile);
}
free(buffer);
  69}
  70
  71
  72bool split_and_save_bitmap(ALLEGRO_BITMAP * input, int slice_w, int slice_h, const char * prefix) {
int x, y;
for(y = 0; y < al_get_bitmap_height(input) ; y += slice_h) {
  for(x = 0; x < al_get_bitmap_width(input)  ; x += slice_w) {
    /* create the sub bitmap */
    ALLEGRO_BITMAP * sub = al_create_sub_bitmap(input, x, y, slice_w, slice_h);
    /* display it, then save it, and then clean up. */
    display_bitmap(sub, x, y, 0.1); 
    save_sub_bitmap(sub, x, y, slice_w, slice_h, prefix);
    al_destroy_bitmap(sub);
  }
}
  84
  85}
  86
  87
  88int main(int argc, char ** argv) {
ALLEGRO_DISPLAY * display = NULL;
ALLEGRO_BITMAP  * input   = NULL;

if (!al_init()) { 
  fprintf(stderr, "Failed to initialize allegro!\n");
  return 1;
}

if (!al_init_image_addon()) {
  fprintf(stderr, "Failed to initialize image addon!\n");
  return 2;
}

display = al_create_display(DISPLAY_W, DISPLAY_H);
if(!display) {
  fprintf(stderr, "Failed to create display!\n");
  return 3;
}

input = al_load_bitmap("input.png");
if (!input) {
  fprintf(stderr, "Failed to load input!\n");
  al_destroy_display(display);
  return 4;
}
/* Display loaded bitmap */
display_bitmap(input, 0.0, 0.0, 0.5);
/* Now split and save it. */
split_and_save_bitmap(input, SKIP_W, SKIP_H, "output");
 118
al_destroy_display(display);
 120}

Oh and here is an example of how to save a binary blob, which would be a bitmap file in your case, using sqlite3 http://www.sqlite.org/cvstrac/wiki?p=BlobExample