VuoImageGet.cc

Go to the documentation of this file.

 
#include "VuoImageGet.h"
#include "VuoUrlFetch.h"
 
#include <string.h>
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
#include <FreeImage.h>
#pragma clang diagnostic pop
 
#include <OpenGL/CGLMacro.h>
 
#include "module.h"
 
extern "C"
{
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "VuoImageGet",
                     "dependencies" : [
                         "VuoImage",
                         "VuoUrlFetch",
                         "freeimage"
                     ]
                 });
#endif
}
 
 
__attribute__((constructor)) static void VuoImageGet_init(void)
{
    FreeImage_Initialise(true);
}
 
static void FreeImageErrorHandler(FREE_IMAGE_FORMAT fif, const char *message)
{
    if (fif != FIF_UNKNOWN)
        VUserLog("Error: %s (%s format)", message, FreeImage_GetFormatFromFIF(fif));
    else
        VUserLog("Error: %s", message);
}
 
float VuoImage_getScaleFactor(const char *url)
{
    VuoText resolvedUrl = VuoUrl_normalize(url, VuoUrlNormalize_default);
    if (!resolvedUrl)
        return 1;
    VuoLocal(resolvedUrl);
 
    VuoText path;
    if (!VuoUrl_getParts(resolvedUrl, NULL, NULL, NULL, NULL, &path, NULL, NULL))
        return 1;
    VuoLocal(path);
 
    size_t lastDot = VuoText_findLastOccurrence(path, ".");
    if (lastDot < 6)
        return 1;
 
    // `@` is URL-escaped as `%40`.
    if (path[lastDot-6] == '%' && path[lastDot-5] == '4' && path[lastDot-4] == '0' && path[lastDot-2] == 'x')
    {
        char c = path[lastDot-3];
        if (c >= '1' && c <= '9')
            return c - '0';
    }
 
    return 1;
}
 
VuoImage VuoImage_get(const char *imageURL)
{
    if (!imageURL || !strlen(imageURL))
        return NULL;
 
    void *data;
    unsigned int dataLength;
    if (!VuoUrl_fetch(imageURL, &data, &dataLength))
        return NULL;
 
    // Decode the memory buffer into a straightforward array of BGRA pixels
    FreeImage_SetOutputMessage(FreeImageErrorHandler);
    FIBITMAP *dib;
    GLuint format;
    VuoImageColorDepth colorDepth;
    unsigned char *pixels;
    unsigned long pixelsWide;
    unsigned long pixelsHigh;
    {
        FIMEMORY *hmem = FreeImage_OpenMemory((BYTE *)data, dataLength);
 
        FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem, 0);
        if (fif == FIF_UNKNOWN)
        {
            VUserLog("Error: '%s': Couldn't determine image type.", imageURL);
            return NULL;
        }
        if (!FreeImage_FIFSupportsReading(fif))
        {
            VUserLog("Error: '%s': This image type doesn't support reading.", imageURL);
            return NULL;
        }
 
        dib = FreeImage_LoadFromMemory(fif, hmem, JPEG_EXIFROTATE);
        FreeImage_CloseMemory(hmem);
 
        if (!dib)
        {
            VUserLog("Error: '%s': Failed to read image.", imageURL);
            return NULL;
        }
 
        pixelsWide = FreeImage_GetWidth(dib);
        pixelsHigh = FreeImage_GetHeight(dib);
 
        const FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);
        const unsigned int bpp = FreeImage_GetBPP(dib);
        const FREE_IMAGE_COLOR_TYPE colorType = FreeImage_GetColorType(dib);
        const FIICCPROFILE *colorProfile = FreeImage_GetICCProfile(dib);
        FITAG *exifColorSpace = NULL;
        FreeImage_GetMetadata(FIMD_EXIF_EXIF, dib, "ColorSpace", &exifColorSpace);
        VDebugLog("ImageFormat=%d  ImageType=%d  BPP=%d  colorType=%s  Profile=%s(%d)  EXIF_ColorSpace=%s", fif, type, bpp,
                  colorType == FIC_MINISWHITE ? "minIsWhite" :
                      (colorType == FIC_MINISBLACK ? "minIsBlack" :
                      (colorType == FIC_RGB ? "RGB" :
                      (colorType == FIC_PALETTE ? "indexed" :
                      (colorType == FIC_RGBALPHA ? "RGBA" :
                      (colorType == FIC_CMYK ? "CMYK" : "unknown"))))),
                  colorProfile->flags & FIICC_COLOR_IS_CMYK ? "CMYK" : "RGB",
                  colorProfile->size,
                  FreeImage_TagToString(FIMD_EXIF_EXIF, exifColorSpace));
 
        if (type == FIT_FLOAT
         || type == FIT_DOUBLE
         || type == FIT_UINT16
         || type == FIT_INT16
         || type == FIT_UINT32
         || type == FIT_INT32)
        {
            // If it is > 8bpc greyscale, convert to float.
            colorDepth = VuoImageColorDepth_32;
            format = GL_LUMINANCE;
 
            FIBITMAP *dibFloat = FreeImage_ConvertToFloat(dib);
            FreeImage_Unload(dib);
            dib = dibFloat;
        }
        else if (type == FIT_RGB16
              || type == FIT_RGBF)
        {
            // If it is > 8bpc WITHOUT an alpha channel, convert to float.
            colorDepth = VuoImageColorDepth_32;
            format = GL_RGB;
 
            FIBITMAP *dibFloat = FreeImage_ConvertToRGBF(dib);
            FreeImage_Unload(dib);
            dib = dibFloat;
        }
        else if (type == FIT_RGBA16
              || type == FIT_RGBAF)
        {
            // If it is > 8bpc WITH an alpha channel, convert to float.
            colorDepth = VuoImageColorDepth_32;
            format = GL_RGBA;
 
            FIBITMAP *dibFloat = FreeImage_ConvertToRGBAF(dib);
            FreeImage_Unload(dib);
            dib = dibFloat;
 
            // FreeImage_PreMultiplyWithAlpha() only works on 8bpc images, so do it ourself.
            float *pixels = (float *)FreeImage_GetBits(dib);
            if (!pixels)
            {
                VUserLog("Error: '%s': Couldn't get pixels from image.", imageURL);
                FreeImage_Unload(dib);
                return NULL;
            }
            for (int y = 0; y < pixelsHigh; ++y)
                for (int x = 0; x < pixelsWide; ++x)
                {
                    float alpha = pixels[(y*pixelsWide + x)*4 + 3];
                    pixels[(y*pixelsWide + x)*4 + 0] *= alpha;
                    pixels[(y*pixelsWide + x)*4 + 1] *= alpha;
                    pixels[(y*pixelsWide + x)*4 + 2] *= alpha;
                }
        }
        else
        {
            // Upload other images as 8bpc.
            colorDepth = VuoImageColorDepth_8;
 
            if (colorType == FIC_MINISWHITE
             || colorType == FIC_MINISBLACK)
            {
                format = GL_LUMINANCE;
 
                FIBITMAP *dibConverted = FreeImage_ConvertTo8Bits(dib);
                FreeImage_Unload(dib);
                dib = dibConverted;
            }
            else if (colorType == FIC_RGB
                 || (colorType == FIC_PALETTE && !FreeImage_IsTransparent(dib)))
            {
                format = GL_BGR;
 
                FIBITMAP *dibConverted = FreeImage_ConvertTo24Bits(dib);
                FreeImage_Unload(dib);
                dib = dibConverted;
            }
            else if (colorType == FIC_RGBALPHA
                 || (colorType == FIC_PALETTE && FreeImage_IsTransparent(dib)))
            {
                format = GL_BGRA;
 
                FIBITMAP *dibConverted = FreeImage_ConvertTo32Bits(dib);
                FreeImage_Unload(dib);
                dib = dibConverted;
 
                if (!FreeImage_PreMultiplyWithAlpha(dib))
                    VUserLog("Warning: Premultiplication failed.");
            }
            else
            {
                VUserLog("Error: '%s': Unknown colorType %d.", imageURL, colorType);
                FreeImage_Unload(dib);
                return NULL;
            }
        }
 
        pixels = FreeImage_GetBits(dib);
        if (!pixels)
        {
            VUserLog("Error: '%s': Couldn't get pixels from image.", imageURL);
            FreeImage_Unload(dib);
            return NULL;
        }
    }
 
    // FreeImage's documentation says "Every scanline is DWORD-aligned."
    // …so round the row stride up to the nearest 4 bytes.
    // See @ref TestVuoImage::testFetchOddStride.
    int bytesPerRow = pixelsWide * VuoGlTexture_getBytesPerPixelForInternalFormat(VuoImageColorDepth_getGlInternalFormat(format, colorDepth));
    bytesPerRow = (bytesPerRow + 3) & ~0x3;
 
    VuoImage vuoImage = VuoImage_makeFromBufferWithStride(pixels, format, pixelsWide, pixelsHigh, bytesPerRow, colorDepth, ^(void *buffer){
        FreeImage_Unload(dib);
        free(data);
    });
    if (!vuoImage)
        return NULL;
 
    vuoImage->scaleFactor = VuoImage_getScaleFactor(imageURL);
 
    return vuoImage;
}