Allegro5 Save bitmap to byte array

Allegro5 Save bitmap to byte array

Kevin NO

Member #13,410

August 2011

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!

beoran

Member #12,636

March 2011

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

Kevin NO

Member #13,410

August 2011

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

Edgar Reynaldo

Major Reynaldo

May 2007

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>code goes here...</code> tags to show your code. Makes it easier to read.

Eagle and Allegro 5 binaries | Older Allegro 4 and 5 binaries | Allegro 5 compile guide
King Piccolo will make it so Then I could just flip it with some sweet, sweet matrix math. In either case, I’ll ride this wagon until the wheels fall off. Thanks to those that keep it running

Thomas Fjellstrom

Member #476

June 2000

Edgar Reynaldo said:

Depends if he wants the actual bitmap headers or not.

--
Thomas Fjellstrom - [website] - [email] - [Allegro Wiki] - [Allegro TODO]
"If you can't think of a better solution, don't try to make a better solution." -- weapon_S
"The less evidence we have for what we believe is certain, the more violently we defend beliefs against those who don't agree" -- https://twitter.com/neiltyson/status/592870205409353730

Edgar Reynaldo

Major Reynaldo

May 2007

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.

Thomas Fjellstrom

Member #476

June 2000

Depends if he wants it to hit the disk or not

Edgar Reynaldo

Major Reynaldo

May 2007

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.

beoran

Member #12,636

March 2011

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?

Kevin NO

Member #13,410

August 2011

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 <stdio.h>
   3#ifdef _MSC_VER
   4#pragma comment ( linker, "/SUBSYSTEM:CONSOLE")
   5#endif #define ALLEGRO_USE_CONSOLE
   6#include <allegro5/allegro.h>
   7#include <allegro5/allegro_memfile.h>
   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 <stdio.h>
  99#include <vector>
 100#include <string>
 101#include "sqlite3.h"
 102#include <allegro5/allegro.h>
 103#include <allegro5/allegro_font.h>
 104#include <allegro5/allegro_ttf.h>
 105#include <allegro5/allegro_image.h>
 106#include <allegro5/allegro_memfile.h>
 107#include "allegro5/allegro_native_dialog.h"
 108#include <fstream>
 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

beoran

Member #12,636

March 2011

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 <allegro5/allegro.h>
   2#include <allegro5/allegro_memfile.h>
   3#include <stdio.h>
   4#include <stdlib.h>
   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