Loading an image from memory?

endeavormac

Is there something along the lines of load_image(void * data, int length) that would allow me to send the data from a support image filetype without having to first save the image to the hdd?

When sending these images over a network, it seems somewhat painful to first have to save them to the disk, and then load them from there.

kazzmir

In Allegro4 you can create a packfile out of memory and use the load_XX_pf routines. Here is my in-memory packfile you can use and a usage of loading PCX files.

#SelectExpand
   1#include <allegro.h>
   2
   3namespace Memory{
  struct memory{
      memory(unsigned char * stream, int length):
          stream(stream),
          position(stream),
          length(length){
      }
  10
      int getSize() const {
          return position - stream;
      }
  14
      /* points to the head */
      unsigned char * stream;
      /* points to the current position */
      unsigned char * position;
      int length;
  };
  21
  static int pf_fclose(void *userdata){
      return 0;
      /* nothing */
  }
  26
  static int pf_getc(void *userdata){
      memory * m = (memory*) userdata;
      if (m->position < m->stream + m->length){
          unsigned char x = *m->position;
          m->position += 1;
          return x;
      }
      return EOF;
  }
  36
  static int pf_ungetc(int c, void *userdata){
      memory * m = (memory*) userdata;
      if (m->position > m->stream){
          m->position -= 1;
          return c;
      } else {
          return EOF;
      }
  }
  46
  static long pf_fread(void *p, long n, void *userdata){
      memory *m = (memory*) userdata;
      unsigned char *cp = (unsigned char *)p;
      long i;
      int c;
  52
      for (i=0; i<n; i++) {
          if ((c = pf_getc(m)) == EOF)
              break;
  56
          *(cp++) = c;
      }
  59
      return i;
  }
  62
  static int pf_putc(int c, void *userdata){
      memory * m = (memory*) userdata;
      if (m->position < m->stream + m->length){
          *m->position = c;
          m->position += 1;
          return c;
      }
      return EOF;
  71
  }
  73
  static long pf_fwrite(const void *p, long n, void *userdata){
      memory *m = (memory*) userdata;
      const unsigned char * cp = (const unsigned char *) p;
      long i;
      int c;
  79
      /* probably should replace this with memcpy */
  81
      for (i=0; i<n; i++) {
          if ((c = pf_putc(cp[i], userdata)) == EOF)
              break;
      }
  86
      return i;
  }
  89
  static int pf_fseek(void *userdata, int offset){
      memory * m = (memory*) userdata;
      if (offset >= 0 && m->position + offset < m->stream + m->length){
          m->position += offset;
          return 0;
      } else {
          return -1;
      }
  }
  99
  static int pf_feof(void *userdata){
      memory * m = (memory*) userdata;
      return m->position >= m->stream + m->length;
  }
 104
  static int pf_ferror(void *userdata){
      memory * m = (memory*) userdata;
      return m->position < m->stream || m->position >= m->stream + m->length;
  }
 109
  static PACKFILE_VTABLE makeTable(){
      PACKFILE_VTABLE table;
      table.pf_fclose = Memory::pf_fclose;
      table.pf_getc = Memory::pf_getc;
      table.pf_ungetc = Memory::pf_ungetc;
      table.pf_fread = Memory::pf_fread;
      table.pf_putc = Memory::pf_putc;
      table.pf_fwrite = Memory::pf_fwrite;
      table.pf_fseek = Memory::pf_fseek;
      table.pf_feof = Memory::pf_feof;
      table.pf_ferror = Memory::pf_ferror;
      return table;
  }
 123}

BITMAP * memoryPCX(unsigned char * const data, const int length){
    PACKFILE_VTABLE table = Memory::makeTable();
    Memory::memory memory(data, length);

    PACKFILE * pack = pack_fopen_vtable(&table, &memory);
    /* need to supply a proper palette at some point */
    RGB * palette = NULL;
    BITMAP * pcx = load_pcx_pf(pack, palette);
    pack_fclose(pack);
    return pcx;
}

endeavormac

They really decided not to make it easy, huh. Thanks for the response.

Bob

There's a simpler way if you can already extract the pixel data from memory. kazzmir's method is great if you have a file loaded in memory, especially one with a non-trivial format.

Thread #605030. Printed from Allegro.cc