Digilib is graphical library written in C, developed by Adam Herout and Pavel Zemčík. Aim of this project is to create set of functions, running on GPU to accelerate image processing. It should be almost transparent to program, using digilib (almost means there is possibility of some additional optimalizations and of course a few initialization functions)

See digilib homepage.

status: complete, yet to debug CPU reference routines and FFT and improve expression evaluator (operation scheduling, temp resource allocation)
language: C / C++ (C interface and C++ engine)
os: os independent

First real results! All the operations are now working on GPU, their CPU equivalents are worked on, day and night. For now, you can see how fast this is going to be:

Every ImageStruct has it's assigned texture. (assignments based on ImageStruct address) Those asignments are created when first doing some operation with a given image. Operations may fail in case it was unable to create texture to hold the image (max texture size limit, image format limit)

Every operation is represented by some shader (almost every, some basic operations can be taken care of just by opengl blending or image processing subset) which is loaded in the moment it's necessary (i.e. when calling some operation first time, it may take more time because shader is being compiled)

Every operation (by default) uploads source images from system memory to texture memory, renders to dest image texture and transfer it to system memory. Such a behavior can be disabled by calling:

void Disable_AutoDownloads()
void Disable_AutoUploads()

Where download means transfer from texture memory to system memory and upload vice versa. In case the source image has no texture associated with it, it's going to be transferred anyway. There are two complementar Enable_* functions as well. There can be situation it's necessary to upload just some images. It can be done either manually by calling:

bool Upload_ImageStruct(const ImageStruct *p_image);
bool Download_ImageStruct(const ImageStruct *p_image);
bool Upload_Async_ImageStruct(const ImageStruct *p_image, int *p_fence_id);
bool Download_Async_ImageStruct(const ImageStruct *p_image, int *p_fence_id);

(note p_fence_id is output parameter, it will contain id of fence, i.e. OpenGL object that can be used to query transfer completeness)

Or by setting "dirty flag". Every image has dirty flag as well. It's a bit, telling wheter image is up-to-date in system memory or in texture memory. Normally those flags are automatically set by image operations, uploads and downloads. In case it's necessary it can be done manualy using function:

void Set_DirtyFlag(const ImageStruct *p_image, bool b_current_on_server);

In case parameter b_current_on_server is true, it means image is up-to-date on server-side (texture memory). In case it's false, it's up-to-date in system memory. Image uploads can be triggered by invalidating the texture (calling with parameter b_current_on_server = false). For now it doesn't affect image downloading as the system memory version of image is marked outdated (dirty flag bit is set high) by image processing functions. Manual image transfer functions doesn't read the flag, they only set it.

For the simplest processing, it's necessary only to include proper headers and to call some initialization code on the beginning of program and some cleanup code on it's end. (cleanup -should- be made automatically by OS's opengl drivers, same as OS frees program's allocated memory when it ends) Here is the simplest use case:

#include <stdio.h> // fprintf
#include <image.h> // ImageStruct
#include "DigiLib_Ext.h" // GPU functions

Init_OpenGL();
// you can use this function from ÜberLame or use GLUT

if(!b_FramebufferObjectSupported()) {
    fprintf(stderr, "error: framebuffer objects not supported, "
        "unable to process images\n");
    return -1;
}
if(!b_NPOTTexturesSupported())
    fprintf(stderr, "warning: non-power-of-two textures not supported\n");
if(!b_FloatTexturesSupported())
    fprintf(stderr, "warning: float textures not supported\n");
// check OpenGL capabilities

// from now on, GPU image processing is transparent

ImageStruct *a, *b, *c; // filled by some data

ImageImageAdd(a, a, b); // a = a + b
ImageImageAdd(a, a, c); // a = a + c
// calculate image sum into a (example image processing)

// image processing end

Free_OpenGL_Objects();
Shutdown_OpenGL();
// cleanup, shutdown opengl

It's kind of dumb, because when calculating a = a + b, image data of a and b are copied to textures, then adding shader is executed and the result is copied back to image a. Then, in next step images a and c are copied to textures (texture for image a actualy contains up-to-date image), images are added and data of image a is downloaded back to a. We could save one image upload and image download here.

The simplest sollution would be to alloc images using

ImageStruct *p_Create_GL_Image(int n_width, int n_height, short n_format);

which creates imagestruct in graphics card memory, mapped to system memory which should save most of unnecessary copying on PCI-X systems. Note memory mapping has to be repeated after every operation with the image (no matter wheter source or destination image) and so it's internal data pointer may change. This will make no difference on AGP systems.

Another, more complicated way is enabling and disabling transfers as follows:

#include <stdio.h> // fprintf
#include <image.h> // ImageStruct
#include "DigiLib_Ext.h" // GPU functions

Init_OpenGL();
// you can use this function from ÜberLame or use GLUT

if(!b_FramebufferObjectSupported()) {
    fprintf(stderr, "error: framebuffer objects not supported, "
        "unable to process images\n");
    return -1;
}
if(!b_NPOTTexturesSupported())
    fprintf(stderr, "warning: non-power-of-two textures not supported\n");
if(!b_FloatTexturesSupported())
    fprintf(stderr, "warning: float textures not supported\n");
// check OpenGL capabilities

// from now on, GPU image processing is transparent

ImageStruct *a, *b, *c; // filled by some data

Disable_AutoDownloads(); // disables image downloading
Disable_AutoUploads(); // disables uploading of up-to-date images

ImageImageAdd(a, a, b); // a = a + b
// a and b weren't uploaded before so they will be uploaded now
// downloads are disabled so a will not be downloaded

Enable_AutoDownloads(); // re-enables image downloading

ImageImageAdd(a, a, c); // a = a + c
// a was uploaded before and it's associated texture contains
// fresh data so it won't be uploaded now
// c wasen't uploaded before so it will be uploaded now
// downloads are enabled and a will be downloaded

Download_ImageStruct(a);
// just another way of getting image a to system memory

// image processing end

Free_OpenGL_Objects();
Shutdown_OpenGL();
// cleanup, shutdown opengl