FreeImage_LoadMultiBitmapFromMemory

DLL_API FIMULTIBITMAP *DLL_CALLCONV
FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags
FI_DEFAULT(0));

Abre un mapa de bits multipágina desde un canal de memoria.

Esta función es similar a FreeImage_OpenMultiBitmap, con la diferencia de que será posible abrir un fichero multipágina, en modo de sólo lectura, desde un canal de memoria en lugar de desde un fichero.

El primer parámetro indica a FreeImage el tipo de mapa de bits a abrir. Actualmente están soportados FIF_TIFF, FIF_ICO y FIF_GIF. El segundo parámetro indica a FreeImage el canal de memoria que ha de decodificar. EL último parámetro se usa para modificar el comportamiento o activar alguna característica del plugin de mapa de bits. Cada plugin tiene su propio conjunto de parámetros.

Aunque el manipulador de memoria de entrada se abre en modo de sólo lectura, usando esta función, los manipuladores de memoria multipágina soportan operaciones de lectura o lectura/escritura. Cuando se modifica un fichero multipágina usando funciones como FreeImage_AppendPage, FreeImage_InsertPage, FreeImage_MovePage o FreeImage_DeletePage, los cambios se almacenan de forma transparente en un caché de memoria de modo que esos cambios pueden ser guardados más tarde a un canal de salida. El canal de memoria de entrada permanece sin modidicar: cerrar el canal de entrada no lo modificará. Se podrá usar entonces algún tipo de función “guardar como…” para guardar los cambios.

static BOOL
extractPagesFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream) {
    char filename[256];
    // open the multipage bitmap stream as read-only
    FIMULTIBITMAP *src = FreeImage_LoadMultiBitmapFromMemory(fif, stream, 0);
    if(src) {
        // get the page count
        int count = FreeImage_GetPageCount(src);
        // extract all pages
        for(int page = 0; page < count; page++) {
            // load the bitmap at position 'page'
            FIBITMAP *dib = FreeImage_LockPage(src, page);
            if(dib) {
                // save the page
                sprintf(filename, "page%d.%s", page, FreeImage_GetFormatFromFIF(fif));
                FreeImage_Save(fif, dib, filename, 0);
                // Unload the bitmap (do not apply any change to src)
                FreeImage_UnlockPage(src, dib, FALSE);
            } else {
                // an error occured: free the multipage bitmap handle and return
                FreeImage_CloseMultiBitmap(src, 0);
                return FALSE;
            }
        }
    }
    // make sure to close the multipage bitmap handle on exit
    return FreeImage_CloseMultiBitmap(src, 0);
}
void testLoadMultiBitmapFromMemory(const char *lpszPathName) {
    struct stat buf;
    int result;
    // get data associated with lpszPathName
    result = stat(lpszPathName, &buf);
    if(result == 0) {
        // allocate a memory buffer and load temporary data
        BYTE *mem_buffer = (BYTE*)malloc(buf.st_size * sizeof(BYTE));
        if(mem_buffer) {
            FILE *stream = fopen(lpszPathName, "rb");
            if(stream) {
                fread(mem_buffer, sizeof(BYTE), buf.st_size, stream);
                fclose(stream);
                // attach the binary data to a memory stream
                FIMEMORY *hmem = FreeImage_OpenMemory(mem_buffer, buf.st_size);
                // get the file type
                FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem, 0);
                // extract pages
                BOOL bSuccess = extractPagesFromMemory(fif, hmem);
                assert(bSuccess);

                // close the stream
                FreeImage_CloseMemory(hmem);
            }
        }
        // user is responsible for freeing the data
        free(mem_buffer);
    }
}