blur.c

#define GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#include <GL/glext.h>
#include <GL/glx.h>
#include <GL/glxext.h>
#include <err.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "blur.h"

extern Display *display;

#if DEBUG_GL
void printShaderInfoLog(GLuint obj) {
    int infologLength = 0;
    int charsWritten = 0;
    char *infoLog;

    glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infologLength);

    if (infologLength > 0) {
        infoLog = (char *)malloc(infologLength);
        glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
        printf("shader_infolog: %s\n", infoLog);
        free(infoLog);
    }
}

void printProgramInfoLog(GLuint obj) {
    int infologLength = 0;
    int charsWritten = 0;
    char *infoLog;

    glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &infologLength);

    if (infologLength > 0) {
        infoLog = (char *)malloc(infologLength);
        glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
        printf("program_infolog: %s\n", infoLog);
        free(infoLog);
    }
}
#endif

/* Variables for GL */
static const char *VERT_SHADER = "varying vec2 v_Coordinates;\n"

                                 "void main(void) {\n"
                                 "gl_Position = ftransform();\n"
                                 "v_Coordinates = vec2(gl_MultiTexCoord0);\n"
                                 "}\n";
static const char *FRAG_SHADER_P1 = "#version 120\n"
                                    "varying vec2 v_Coordinates;\n"

                                    "uniform vec2 u_Scale;\n"
                                    "uniform sampler2D u_Texture0;\n";

static const char *FRAG_SHADER_F1 = "const vec2 gaussFilter[%d] = \n"
                                    "vec2[](\n";
static const char *FRAG_SHADER_F2 = "vec2 (%f, %f),\n";
static const char *FRAG_SHADER_F3 = "vec2 (%f, %f)\n"
                                    ");\n";

static const char *FRAG_SHADER_P3 = "void main()\n"
                                    "{\n"
                                    "vec4 color = vec4(0.0,0.0,0.0,0.0);\n";
static const char *FRAG_SHADER_F4 = "for( int i = 0; i < %d; i++ )\n";
static const char *FRAG_SHADER_P4 =
    "{\n"
    "color += texture2D( u_Texture0, vec2( "
    "v_Coordinates.x+gaussFilter[i].x*u_Scale.x, "
    "v_Coordinates.y+gaussFilter[i].x*u_Scale.y ) )*gaussFilter[i].y;\n"
    "}\n"
    "gl_FragColor = color;\n"
    "}\n";

static char *generate_fragment_shader(int blur_radius, float sigma) {
    // First, generate the normal Gaussian weights for a given sigma
    float *standardGaussianWeights = calloc(blur_radius + 1, sizeof(float));
    float sumOfWeights = 0.0;
    for (int currentGaussianWeightIndex = 0;
         currentGaussianWeightIndex < blur_radius + 1;
         currentGaussianWeightIndex++) {
        standardGaussianWeights[currentGaussianWeightIndex] =
            (1.0 / sqrt(2.0 * M_PI * pow(sigma, 2.0))) *
            exp(-pow(currentGaussianWeightIndex, 2.0) /
                (2.0 * pow(sigma, 2.0)));

        if (currentGaussianWeightIndex == 0) {
            sumOfWeights += standardGaussianWeights[currentGaussianWeightIndex];
        } else {
            sumOfWeights +=
                2.0 * standardGaussianWeights[currentGaussianWeightIndex];
        }
    }

    // Next, normalize these weights to prevent the clipping of the Gaussian
    // curve at the end of the discrete samples from reducing luminance
    for (int currentGaussianWeightIndex = 0;
         currentGaussianWeightIndex < blur_radius + 1;
         currentGaussianWeightIndex++) {
        standardGaussianWeights[currentGaussianWeightIndex] =
            standardGaussianWeights[currentGaussianWeightIndex] / sumOfWeights;
    }

    // From these weights we calculate the offsets to read interpolated values
    // from
    int numberOfOptimizedOffsets = blur_radius / 2 + (blur_radius % 2);
    float *optimizedGaussianOffsets =
        calloc(numberOfOptimizedOffsets, sizeof(float));
    float *optimizedGaussianWeights =
        calloc(numberOfOptimizedOffsets, sizeof(float));

    for (int currentOptimizedOffset = 0;
         currentOptimizedOffset < numberOfOptimizedOffsets;
         currentOptimizedOffset++) {
        float firstWeight =
            standardGaussianWeights[currentOptimizedOffset * 2 + 1];
        float secondWeight =
            standardGaussianWeights[currentOptimizedOffset * 2 + 2];

        float optimizedWeight = firstWeight + secondWeight;

        optimizedGaussianWeights[currentOptimizedOffset] = optimizedWeight;
        optimizedGaussianOffsets[currentOptimizedOffset] =
            (firstWeight * (currentOptimizedOffset * 2 + 1) +
             secondWeight * (currentOptimizedOffset * 2 + 2)) /
            optimizedWeight;
    }
    int size = sizeof(char) * (450 + 56 * numberOfOptimizedOffsets);
    char *output = (char *)malloc(size);
    char buf[512];
    strcpy(output, FRAG_SHADER_P1);
    sprintf(buf, FRAG_SHADER_F1, 2 * numberOfOptimizedOffsets + 1);
    strcat(output, buf);
    sprintf(buf, FRAG_SHADER_F2, 0.0, standardGaussianWeights[0]);
    strcat(output, buf);
    for (int i = 0; i != numberOfOptimizedOffsets - 1; ++i) {
        sprintf(buf, FRAG_SHADER_F2, optimizedGaussianOffsets[i],
                optimizedGaussianWeights[i]);
        strcat(output, buf);
        sprintf(buf, FRAG_SHADER_F2, -optimizedGaussianOffsets[i],
                optimizedGaussianWeights[i]);
        strcat(output, buf);
    }
    sprintf(buf, FRAG_SHADER_F2,
            optimizedGaussianOffsets[numberOfOptimizedOffsets - 1],
            optimizedGaussianWeights[numberOfOptimizedOffsets - 1]);
    strcat(output, buf);
    sprintf(buf, FRAG_SHADER_F3,
            -optimizedGaussianOffsets[numberOfOptimizedOffsets - 1],
            optimizedGaussianWeights[numberOfOptimizedOffsets - 1]);
    strcat(output, buf);
    strcat(output, FRAG_SHADER_P3);
    sprintf(buf, FRAG_SHADER_F4, 2 * numberOfOptimizedOffsets + 1);
    strcat(output, buf);
    strcat(output, FRAG_SHADER_P4);
    free(standardGaussianWeights);
    free(optimizedGaussianWeights);
    free(optimizedGaussianOffsets);
    return output;
}

GLXFBConfig *configs = NULL;
GLXContext ctx;
Pixmap tmp;
GLXPixmap glx_tmp;
Pixmap tmp1;
GLXPixmap glx_tmp1;
GLXPixmap glx_pixmap;
XVisualInfo *vis;
GLuint shader_prog;
GLuint v_shader;
GLuint f_shader;
static PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT_f = NULL;
static PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT_f = NULL;
const int pixmap_config[] = {GLX_BIND_TO_TEXTURE_RGBA_EXT,
                             True,
                             GLX_DRAWABLE_TYPE,
                             GLX_PIXMAP_BIT,
                             GLX_BIND_TO_TEXTURE_TARGETS_EXT,
                             GLX_TEXTURE_2D_BIT_EXT,
                             GLX_DOUBLEBUFFER,
                             False,
                             GLX_Y_INVERTED_EXT,
                             GLX_DONT_CARE,
                             None};
const int pixmap_attribs[] = {GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
                              GLX_TEXTURE_FORMAT_EXT,
                              GLX_TEXTURE_FORMAT_RGB_EXT, None};

void glx_init(int scr, int w, int h, int radius, float sigma) {
    int i;
    configs = glXChooseFBConfig(display, scr, pixmap_config, &i);
    vis = glXGetVisualFromFBConfig(display, configs[0]);
    ctx = glXCreateContext(display, vis, NULL, True);

    glXBindTexImageEXT_f = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress(
        (GLubyte *)"glXBindTexImageEXT");
    if (glXBindTexImageEXT_f == NULL) {
        errx(EXIT_FAILURE, "Failed to load extension glXBindTexImageEXT.\n");
    }

    glXReleaseTexImageEXT_f = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress(
        (GLubyte *)"glXReleaseTexImageEXT");

    if (glXReleaseTexImageEXT_f == NULL) {
        errx(EXIT_FAILURE, "Failed to load extension glXReleaseTexImageEXT.\n");
    }

    tmp = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                        vis->depth);
    glx_tmp = glXCreatePixmap(display, configs[0], tmp, pixmap_attribs);
    glXMakeCurrent(display, glx_tmp, ctx);

    tmp1 = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                         vis->depth);
    glx_tmp1 = glXCreatePixmap(display, configs[0], tmp1, pixmap_attribs);

    v_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(v_shader, 1, &VERT_SHADER, NULL);
    glCompileShader(v_shader);
    glGetShaderiv(v_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
    printf("V Shader: %d\n", i);
    printShaderInfoLog(v_shader);
#endif
    f_shader = glCreateShader(GL_FRAGMENT_SHADER);
    char *fragment_shader = generate_fragment_shader(radius, sigma);
    GLchar const *files[] = {fragment_shader};
    glShaderSource(f_shader, 1, files, NULL);
    free(fragment_shader);
    glCompileShader(f_shader);
    glGetShaderiv(f_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
    printf("F Shader: %d\n", i);
    printShaderInfoLog(f_shader);
#endif
    shader_prog = glCreateProgram();
    glAttachShader(shader_prog, v_shader);
    glAttachShader(shader_prog, f_shader);
    glLinkProgram(shader_prog);
    glGetShaderiv(f_shader, GL_LINK_STATUS, &i);
#if DEBUG_GL
    printf("Program: %d\n", i);
    printShaderInfoLog(f_shader);
    printProgramInfoLog(shader_prog);
#endif
}

static void glx_free_pixmaps(void) {
    glXDestroyPixmap(display, glx_tmp);
    glXDestroyPixmap(display, glx_tmp1);
    XFreePixmap(display, tmp);
    XFreePixmap(display, tmp1);
}

void glx_resize(int w, int h) {
    /* free old pixmaps */
    glx_free_pixmaps();

    /* create new pixmaps */
    tmp = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                        vis->depth);
    glx_tmp = glXCreatePixmap(display, configs[0], tmp, pixmap_attribs);
    glXMakeCurrent(display, glx_tmp, ctx);
    tmp1 = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
                         vis->depth);
    glx_tmp1 = glXCreatePixmap(display, configs[0], tmp1, pixmap_attribs);
}

void glx_deinit(void) {
    glx_free_pixmaps();
    glDetachShader(shader_prog, v_shader);
    glDetachShader(shader_prog, f_shader);
    glDeleteShader(v_shader);
    glDeleteShader(f_shader);
    glDeleteProgram(shader_prog);
    glXDestroyContext(display, ctx);
    XFree(vis);
    XFree(configs);
}

void blur_image_gl(int scr, Pixmap pixmap, int width, int height, int radius,
                   float sigma) {
    if (configs == NULL) {
        glx_init(scr, width, height, radius, sigma);
    }

    glx_pixmap = glXCreatePixmap(display, configs[0], pixmap, pixmap_attribs);

    for (uint8_t i = 0; i < 2; ++i) {
        if ((i & 1) == 0) {
            glXMakeCurrent(display, glx_tmp, ctx);
        } else {
            glXMakeCurrent(display, glx_tmp1, ctx);
        }
        glEnable(GL_TEXTURE_2D);
        if (i == 0) {
            glXBindTexImageEXT_f(display, glx_pixmap, GLX_FRONT_EXT, NULL);
        } else {
            glXBindTexImageEXT_f(display, (i & 1) == 1 ? glx_tmp : glx_tmp1,
                                 GLX_FRONT_EXT, NULL);
        }
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glViewport(0, 0, (GLsizei)width, (GLsizei)height);
        glClearColor(0.3, 0.3, 0.3, 1.0);
        glClear(GL_COLOR_BUFFER_BIT);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(-1.0, 1.0, -1.0, 1.0, -1., 1);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        glColor3f(0.0, 0.0, 1.0);

        glUseProgram(shader_prog);
        GLint u_Scale = glGetUniformLocation(shader_prog, "u_Scale");
        if ((i & 1) == 0) {
            glUniform2f(u_Scale, 1.0 / width, 0);
        } else {
            glUniform2f(u_Scale, 0, 1.0 / height);
        }

        glBegin(GL_QUADS);
        glTexCoord2f(0.0, 0.0);
        glVertex2f(-1.0, 1.0);
        glTexCoord2f(1.0, 0.0);
        glVertex2f(1.0, 1.0);
        glTexCoord2f(1.0, 1.0);
        glVertex2f(1.0, -1.0);
        glTexCoord2f(0.0, 1.0);
        glVertex2f(-1.0, -1.0);
        glEnd();
        glFlush();

        if (i == 0) {
            glXReleaseTexImageEXT_f(display, glx_pixmap, GLX_FRONT_EXT);
        } else {
            glXReleaseTexImageEXT_f(display, (i & 1) == 1 ? glx_tmp : glx_tmp1,
                                    GLX_FRONT_EXT);
        }
    }
    GC gc = XCreateGC(display, pixmap, 0, NULL);
    XCopyArea(display, tmp1, pixmap, gc, 0, 0, width, height, 0, 0);
    XFreeGC(display, gc);
    glXDestroyPixmap(display, glx_pixmap);
}