soft_image.c

/* Copyright (c) 2015, Benjamin Huber
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * Neither the name of the copyright holder nor the
 *      names of its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <jpeglib.h>
#include <png.h>

#include "libnsbmp/libnsbmp.h"
#include "libnsgif/libnsgif.h"
#include "soft_image.h"

#define ALIGN16(x) (((x + 0xf) >> 4) << 4)

#define MIN_FRAME_DELAY_CS 2
#define BUMP_UP_FRAME_DELAY_CS 10

static const char magExif[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};

struct my_error_mgr
{
    struct jpeg_error_mgr pub;
    jmp_buf setjmp_buffer;
};

typedef struct my_error_mgr* my_error_ptr;

METHODDEF(void)
my_error_exit(j_common_ptr cinfo)
{
    my_error_ptr myerr = (my_error_ptr)cinfo->err;
    longjmp(myerr->setjmp_buffer, 1);
}

int readJpegHeader(FILE* infile, JPEG_INFO* jpegInfo)
{
    struct jpeg_decompress_struct cinfo;

    struct my_error_mgr jerr;

    if (infile == NULL)
    {
        return SOFT_IMAGE_ERROR_FILE_OPEN;
    }

    cinfo.err = jpeg_std_error(&jerr.pub);
    jerr.pub.error_exit = my_error_exit;
    if (setjmp(jerr.setjmp_buffer))
    {
        jpeg_destroy_decompress(&cinfo);
        return SOFT_IMAGE_ERROR_DECODING;
    }

    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);
    jpeg_save_markers(&cinfo, JPEG_APP0 + 1, 0xffff);
    jpeg_read_header(&cinfo, TRUE);

    if (cinfo.progressive_mode)
        jpegInfo->mode = JPEG_MODE_PROGRESSIVE;
    else
        jpegInfo->mode = JPEG_MODE_NON_PROGRESSIVE;

    jpegInfo->nColorComponents = cinfo.num_components;

    // read EXIF orientation
    // losely base on: http://sylvana.net/jpegcrop/jpegexiforient.c
    jpegInfo->orientation = 1; // Default
    jpeg_saved_marker_ptr pMarker = cinfo.marker_list;

    if (pMarker != NULL && pMarker->data_length >= 20 &&
        memcmp(pMarker->data, magExif, sizeof(magExif)) == 0)
    {

        unsigned int exifLen = pMarker->data_length;
        uint8_t* exifData = pMarker->data;
        short motorola;

        // byte order
        if (exifData[6] == 0x49 && exifData[7] == 0x49)
            motorola = 0;
        else if (exifData[6] == 0x4D && exifData[7] == 0x4D)
            motorola = 1;
        else
            goto cleanExit;

        if (motorola)
        {
            if (exifData[8] != 0 || exifData[9] != 0x2A)
                goto cleanExit;
        }
        else
        {
            if (exifData[9] != 0 || exifData[8] != 0x2A)
                goto cleanExit;
        }

        unsigned int offset;
        // read offset to IFD0
        if (motorola)
        {
            if (exifData[10] != 0 || exifData[11] != 0)
                goto cleanExit;
            offset = (exifData[12] << 8) + exifData[13] + 6;
        }
        else
        {
            if (exifData[12] != 0 || exifData[13] != 0)
                goto cleanExit;
            offset = (exifData[11] << 8) + exifData[10] + 6;
        }
        if (offset > exifLen - 14)
            goto cleanExit;

        unsigned int nTags;

        // read number of tags in IFD0
        if (motorola)
            nTags = (exifData[offset] << 8) + exifData[offset + 1];
        else
            nTags = (exifData[offset + 1] << 8) + exifData[offset];

        offset += 2;

        while (1)
        {
            if (nTags-- == 0 || offset > exifLen - 12)
                goto cleanExit;

            unsigned int tag;
            if (motorola)
                tag = (exifData[offset] << 8) + exifData[offset + 1];
            else
                tag = (exifData[offset + 1] << 8) + exifData[offset];

            if (tag == 0x0112) break; // orientation tag found

            offset += 12;
        }

        unsigned char orientation = 9;

        if (motorola && exifData[offset + 8] == 0)
        {
            orientation = exifData[offset + 9];
        }
        else if (exifData[offset + 9] == 0)
        {
            orientation = exifData[offset + 8];
        }

        if (orientation <= 8 && orientation != 0)
            jpegInfo->orientation = orientation;
    }

cleanExit:

    jpeg_destroy_decompress(&cinfo);

    return SOFT_IMAGE_OK;
}

int softDecodeJpeg(FILE* infile, IMAGE* jpeg)
{
    struct jpeg_decompress_struct cinfo;
    struct my_error_mgr jerr;
    JSAMPARRAY buffer;
    unsigned int rowStride;

    cinfo.err = jpeg_std_error(&jerr.pub);
    jerr.pub.error_exit = my_error_exit;
    if (setjmp(jerr.setjmp_buffer))
    {
        jpeg_destroy_decompress(&cinfo);
        return SOFT_IMAGE_ERROR_DECODING;
    }

    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);
    jpeg_read_header(&cinfo, TRUE);

    cinfo.out_color_space = JCS_RGB;

    jpeg_start_decompress(&cinfo);

    rowStride = cinfo.output_width * cinfo.output_components;

    jpeg->width = cinfo.output_width;

    /* Stride memory needs to be a multiple of 16,
     * otherwise resize and render component will bug. */
    unsigned int stride = ALIGN16(jpeg->width) * 4;

    jpeg->height = cinfo.output_height;
    jpeg->colorSpace = COLOR_SPACE_RGBA;

    buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE, rowStride, 1);
    size_t i, x, y;

    jpeg->nData = stride * ALIGN16(cinfo.output_height);
    jpeg->pData = malloc(jpeg->nData);
    if (jpeg->pData == NULL)
    {
        jpeg_finish_decompress(&cinfo);
        jpeg_destroy_decompress(&cinfo);
        return SOFT_IMAGE_ERROR_MEMORY;
    }

    size_t rBytes = cinfo.output_width * 4;

    // Copy and convert from RGB to RGBA
    for (i = 0; cinfo.output_scanline < cinfo.output_height; i += stride)
    {
        jpeg_read_scanlines(&cinfo, buffer, 1);
        for (x = 0, y = 0; x < rBytes; x += 4, y += 3)
        {
            jpeg->pData[i + x + 3] = 255;
            memcpy(jpeg->pData + i + x, buffer[0] + y, 3);
        }
    }

    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    if (jerr.pub.num_warnings != 0)
    {
        return SOFT_IMAGE_ERROR_CORRUPT_DATA;
    }

    return SOFT_IMAGE_OK;
}

/**
 * Modified from https://gist.github.com/niw/5963798
 * Copyright (C) Guillaume Cottenceau, Yoshimasa Niwa
 * Distributed under the MIT License.
 **/
int softDecodePng(FILE* fp, IMAGE* png)
{
    png_byte header[8];

    png_structp png_ptr;
    png_infop info_ptr;

    if (!fp)
        return SOFT_IMAGE_ERROR_FILE_OPEN;
    fread(header, 1, 8, fp);
    if (png_sig_cmp(header, 0, 8))
    {
        return SOFT_IMAGE_ERROR_FILE_OPEN;
    }

    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

    if (!png_ptr)
    {
        return SOFT_IMAGE_ERROR_CREATE_STRUCT;
    }

    info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
    {
        return SOFT_IMAGE_ERROR_CREATE_STRUCT;
    }

    if (setjmp(png_jmpbuf(png_ptr)))
    {
        return SOFT_IMAGE_ERROR_INIT;
    }

    png_init_io(png_ptr, fp);
    png_set_sig_bytes(png_ptr, 8);

    png_read_info(png_ptr, info_ptr);

    png_byte color_type = png_get_color_type(png_ptr, info_ptr);
    png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);

    if (bit_depth == 16)
        png_set_strip_16(png_ptr);

    if (color_type == PNG_COLOR_TYPE_PALETTE)
        png_set_palette_to_rgb(png_ptr);

    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
        png_set_expand_gray_1_2_4_to_8(png_ptr);

    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
        png_set_tRNS_to_alpha(png_ptr);

    if (color_type == PNG_COLOR_TYPE_RGB ||
        color_type == PNG_COLOR_TYPE_GRAY ||
        color_type == PNG_COLOR_TYPE_PALETTE)
    {

        png_set_filler(png_ptr, 0xFF, PNG_FILLER_AFTER);
    }

    if (color_type == PNG_COLOR_TYPE_GRAY ||
        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
        png_set_gray_to_rgb(png_ptr);

    png_read_update_info(png_ptr, info_ptr);

    png->width = png_get_image_width(png_ptr, info_ptr);

    /* Stride memory needs to be a multiple of 16,
     * otherwise resize and render component will bug. */
    unsigned int stride = ALIGN16(png->width) * 4;

    png->height = png_get_image_height(png_ptr, info_ptr);

    png->colorSpace = COLOR_SPACE_RGBA;

    if (setjmp(png_jmpbuf(png_ptr)))
    {
        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        return SOFT_IMAGE_ERROR_DECODING;
    }

    png->nData = ALIGN16(png->height) * stride;
    png->pData = malloc(png->nData);
    if (!png->pData)
    {
        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        return SOFT_IMAGE_ERROR_MEMORY;
    }

    png_bytep row_pointers[png->height];
    size_t i;
    for (i = 0; i < png->height; i++)
    {
        row_pointers[i] = (png_bytep)png->pData + i * (stride);
    }

    png_read_image(png_ptr, row_pointers);

    png_read_end(png_ptr, NULL);
    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);

    return SOFT_IMAGE_OK;
}

// BMP

static void* bmp_init(int width, int height, unsigned int state)
{
    return malloc(ALIGN16(width) * ALIGN16(height) * 4);
}

static unsigned char* bmp_get_buffer(void* bitmap)
{
    return bitmap;
}

static size_t bmp_get_bpp(void* bitmap)
{
    return 4;
}

int softDecodeBMP(FILE* fp, IMAGE* bmpImage, unsigned char** data, size_t size)
{
    bmp_bitmap_callback_vt bitmap_callbacks = {
        bmp_init,
        NULL,
        bmp_get_buffer,
        bmp_get_bpp};
    bmp_result code;
    bmp_image bmp;
    short ret = 0;

    if (!fp)
    {
        return SOFT_IMAGE_ERROR_FILE_OPEN;
    }

    if (data == NULL || *data == NULL)
    {

        fseek(fp, 0L, SEEK_END);
        size = ftell(fp);
        fseek(fp, 0L, SEEK_SET);

        *data = malloc(size);
        if (!*data)
        {
            return SOFT_IMAGE_ERROR_MEMORY;
        }

        if (fread(*data, 1, size, fp) != size)
        {
            free(*data);
            *data = NULL;
            return SOFT_IMAGE_ERROR_MEMORY;
        }
    }

    bmp_create(&bmp, &bitmap_callbacks);

    code = bmp_analyse(&bmp, size, *data);
    if (code != BMP_OK)
    {
        ret = SOFT_IMAGE_ERROR_ANALYSING;
        goto cleanup;
    }

    code = bmp_decode(&bmp);
    if (code != BMP_OK)
    {
        ret = SOFT_IMAGE_ERROR_DECODING;
        goto cleanup;
    }

    uint8_t* bmpData = bmp.bitmap;
    int bmpWidth = bmp.width;

    bmpImage->height = bmp.height;
    bmpImage->width = bmpWidth;
    bmpImage->colorSpace = COLOR_SPACE_RGBA;

    bmp_finalise(&bmp);
    free(*data);
    *data = NULL;

    /* Stride memory needs to be a multiple of 16,
     * otherwise resize and render component will bug. */
    unsigned int stride = ALIGN16(bmpWidth) * 4;

    bmpImage->nData = stride * ALIGN16(bmpImage->height);

    bmpImage->pData = bmpData;

    unsigned int pixWidth = bmpWidth * 4;
    unsigned int i;
    for (i = bmpImage->height; --i > 0;)
    {
        memmove(bmpImage->pData + i * stride,
                bmpData + i * pixWidth, pixWidth);
    }

    return ret;

cleanup:
    bmp_finalise(&bmp);
    free(*data);
    *data = NULL;
    return ret;
}

// GIF

static void* gif_init(int width, int height)
{
    return malloc(width * height * 4);
}

static unsigned char* gif_get_buffer(void* bitmap)
{
    return bitmap;
}

static void gif_destroy(void* bitmap)
{
    free(bitmap);
}

void destroyAnimImage(ANIM_IMAGE* animIm)
{
    gif_animation* gif = (gif_animation*)animIm->pExtraData;
    gif_finalise(gif);
    if (animIm->frames)
    {
        unsigned int i;
        for (i = 0; i < animIm->frameCount; i++)
        {
            destroyImage(&animIm->frames[i]);
        }
        free(animIm->frames);
        animIm->frames = NULL;
    }
    else if (animIm->curFrame)
    {
        destroyImage(animIm->curFrame);
    }
    free(animIm->imData);
    free(animIm->pExtraData);
    memset(animIm, 0, sizeof(ANIM_IMAGE));
}

static int decodeNextGifFrame(ANIM_IMAGE* gifImage)
{
    if (!gifImage->imData || !gifImage->curFrame->pData)
    {
        return SOFT_IMAGE_ERROR_MEMORY;
    }
    int ret;

    gif_animation* gif = (gif_animation*)gifImage->pExtraData;
    gif_result code;

    gifImage->frameNum++;
    gifImage->frameNum %= gifImage->frameCount;

    unsigned int stride = ALIGN16(gif->width) * 4;
    if (gif->frames[gifImage->frameNum].frame_delay < MIN_FRAME_DELAY_CS)
        gifImage->frameDelayCs = BUMP_UP_FRAME_DELAY_CS;
    else
        gifImage->frameDelayCs = gif->frames[gifImage->frameNum].frame_delay;

    if (gifImage->frames)
    {
        gifImage->curFrame = &(gifImage->frames[gifImage->frameNum]);
    }
    if (gifImage->frames == NULL || gifImage->decodeCount < gifImage->frameCount)
    {
        code = gif_decode_frame(gif, gifImage->frameNum);
        if (code != GIF_OK)
        {
            ret = SOFT_IMAGE_ERROR_DECODING;
            goto cleanup;
        }

        unsigned int pixWidth = gif->width * 4;
        unsigned int n, i, gifSize = pixWidth * gif->height;
        for (n = 0, i = 0; n < gifSize; n += pixWidth, i += stride)
        {
            memcpy(gifImage->curFrame->pData + i,
                   gif->frame_image + n, pixWidth);
        }

        if (gifImage->frames)
            gifImage->decodeCount++;
    }

    return SOFT_IMAGE_OK;

cleanup:
    destroyAnimImage(gifImage);
    return ret;
}

int softDecodeGif(FILE* fp, ANIM_IMAGE* gifImage, unsigned char** data, size_t size)
{
    gif_bitmap_callback_vt bitmap_callbacks = {
        gif_init,
        gif_destroy,
        gif_get_buffer,
        NULL,
        NULL,
        NULL};

    int ret;
    gif_animation* gif = malloc(sizeof(gif_animation));
    if (!gif)
        return SOFT_IMAGE_ERROR_MEMORY;
    gif_result code;
    gifImage->pExtraData = gif;
    gifImage->frameCount = 0;

    if (!fp)
    {
        return SOFT_IMAGE_ERROR_FILE_OPEN;
    }

    if (data == NULL || *data == NULL)
    {

        fseek(fp, 0L, SEEK_END);
        size = ftell(fp);
        fseek(fp, 0L, SEEK_SET);

        *data = malloc(size);
        if (!*data)
        {
            return SOFT_IMAGE_ERROR_MEMORY;
        }

        if (fread(*data, 1, size, fp) != size)
        {
            free(*data);
            *data = NULL;
            return SOFT_IMAGE_ERROR_MEMORY;
        }
    }

    gifImage->size = size;
    gifImage->imData = *data;

    gif_create(gif, &bitmap_callbacks);
    gifImage->decodeNextFrame = decodeNextGifFrame;
    gifImage->finaliseDecoding = destroyAnimImage;

    do
    {
        code = gif_initialise(gif, size, *data);
        if (code != GIF_OK && code != GIF_WORKING)
        {
            ret = SOFT_IMAGE_ERROR_ANALYSING;
            goto cleanup;
        }
    } while (code != GIF_OK);

    gifImage->frameCount = gif->frame_count;
    gifImage->loopCount = gif->loop_count;

    unsigned int stride = ALIGN16(gif->width) * 4;

    size_t nData = stride * ALIGN16(gif->height);

    unsigned int i = 0;
    if (gifImage->frameCount > 1)
    {
        gifImage->frames = malloc(gifImage->frameCount * sizeof(IMAGE));
        if (!gifImage->frames)
        {
            ret = SOFT_IMAGE_ERROR_MEMORY;
            goto cleanup;
        }

        for (; i < gifImage->frameCount; i++)
        {
            gifImage->frames[i].pData = malloc(nData);
            gifImage->frames[i].nData = nData;
            gifImage->frames[i].width = gif->width;
            gifImage->frames[i].height = gif->height;
            gifImage->frames[i].colorSpace = COLOR_SPACE_RGBA;
            if (!gifImage->frames[i].pData)
            {
                break;
            }
        }
    }

    if (i < gifImage->frameCount)
    {
        if (gifImage->frames)
        {
            for (; i < gifImage->frameCount; i--)
            {
                if (gifImage->frames[i].pData)
                    destroyImage(&gifImage->frames[i]);
            }
            free(gifImage->frames);
            gifImage->frames = NULL;
        }
        gifImage->curFrame->pData = malloc(nData);
        if (!gifImage->curFrame->pData)
        {
            ret = SOFT_IMAGE_ERROR_MEMORY;
            goto cleanup;
        }
        gifImage->curFrame->nData = nData;
        gifImage->curFrame->width = gif->width;
        gifImage->curFrame->height = gif->height;
        gifImage->curFrame->colorSpace = COLOR_SPACE_RGBA;
    }
    else
    {
        gifImage->curFrame = gifImage->frames;
    }

    gifImage->frameNum = 0;

    if (gif->frames[gifImage->frameNum].frame_delay < MIN_FRAME_DELAY_CS)
        gifImage->frameDelayCs = BUMP_UP_FRAME_DELAY_CS;
    else
        gifImage->frameDelayCs = gif->frames[gifImage->frameNum].frame_delay;

    code = gif_decode_frame(gif, gifImage->frameNum);
    if (code != GIF_OK)
    {
        ret = SOFT_IMAGE_ERROR_DECODING;
        goto cleanup;
    }

    unsigned int pixWidth = gif->width * 4;
    unsigned int n, gifSize = pixWidth * gif->height;
    for (n = 0, i = 0; n < gifSize; n += pixWidth, i += stride)
    {
        memcpy(gifImage->curFrame->pData + i,
               gif->frame_image + n, pixWidth);
    }
    gifImage->decodeCount = 1;

    *data = NULL;
    if (gifImage->frameCount < 2)
    {
        gif_finalise(gif);
        free(gifImage->imData);
        free(gifImage->pExtraData);
    }

    return SOFT_IMAGE_OK;

cleanup:
    destroyAnimImage(gifImage);
    *data = NULL;
    return ret;
}

// TIFF

static int32_t tiffRead(void* st, void* buffer, int32_t size)
{
    return fread(buffer, 1, size, (FILE*)st);
}

static uint32_t tiffSeek32(void* st, uint32_t pos, int whence)
{
    int ret = fseek((FILE*)st, pos, whence);
    if (ret == 0)
        return pos;
    else
        return -1;
}

static uint64_t tiffSeek64(void* st, uint64_t pos, int whence)
{
    int ret = fseek((FILE*)st, pos, whence);
    if (ret == 0)
        return pos;
    else
        return -1;
}

static int32_t dummyTiffWrite(void* st, void* buffer, int32_t size) { return 0; }
static int dummyTiffClose(void* st) { return 0; }
static uint32_t dummyTiffSize(void* st) { return 0; }
static int dummyTiffMap(void* st, void** addr, uint32_t* size) { return 0; }
static void dummyTiffUnmap(void* st, void* addr, uint32_t size) {}

static void* libTiffHandle = NULL;
static int libTiffVersion = 5;
static void* (*TIFFClientOpen)(const char*, const char*, void*,
                               void*, void*, void*, void*, void*, void*, void*);
static int (*TIFFGetField)(void*, uint32_t, ...);
static int (*TIFFReadRGBAImageOriented)(void*, uint32_t, uint32_t, uint32_t*, int, int);
static void (*TIFFClose)(void*);

void unloadLibTiff()
{
    if (libTiffHandle)
        dlclose(libTiffHandle);
    libTiffHandle = NULL;
}

static int loadLibTiff()
{
    char* error = NULL;
    if (libTiffHandle == NULL)
    {

        libTiffHandle = dlopen("libtiff.so.5", RTLD_LAZY);
        if (!libTiffHandle)
        {
            libTiffHandle = dlopen("libtiff.so.4", RTLD_LAZY);
            if (!libTiffHandle)
            {
                goto error;
            }
            libTiffVersion = 4;
        }

        TIFFClientOpen = dlsym(libTiffHandle, "TIFFClientOpen");
        if ((error = dlerror()) != NULL)
            goto error;

        TIFFGetField = dlsym(libTiffHandle, "TIFFGetField");
        if ((error = dlerror()) != NULL)
            goto error;

        TIFFReadRGBAImageOriented = dlsym(libTiffHandle, "TIFFReadRGBAImageOriented");
        if ((error = dlerror()) != NULL)
            goto error;

        TIFFClose = dlsym(libTiffHandle, "TIFFClose");
        if ((error = dlerror()) != NULL)
            goto error;
    }
    return 0;
error:
    fprintf(stderr, "%s\n", error);
    unloadLibTiff();
    return 1;
}

int softDecodeTIFF(FILE* fp, IMAGE* im)
{
    int ret = SOFT_IMAGE_OK;

    if (loadLibTiff() == 1)
        return SOFT_IMAGE_ERROR_INIT;

    void* tif;
    if (libTiffVersion == 5)
        tif = TIFFClientOpen("FILE", "r", (void*)fp,
                             tiffRead, dummyTiffWrite, tiffSeek64, dummyTiffClose,
                             dummyTiffSize, dummyTiffMap, dummyTiffUnmap);
    else
        tif = TIFFClientOpen("FILE", "r", (void*)fp,
                             tiffRead, dummyTiffWrite, tiffSeek32, dummyTiffClose,
                             dummyTiffSize, dummyTiffMap, dummyTiffUnmap);
    if (tif != NULL)
    {
        TIFFGetField(tif, /* TIFFTAG_IMAGEWIDTH */ 256, (uint32_t*)&im->width);
        TIFFGetField(tif, /* TIFFTAG_IMAGELENGTH */ 257, (uint32_t*)&im->height);
        unsigned int stride = ALIGN16(im->width) * 4;
        im->nData = stride * ALIGN16(im->height);
        im->pData = malloc(im->nData);
        im->colorSpace = COLOR_SPACE_RGBA;
        if (im->pData != NULL)
        {
            if (TIFFReadRGBAImageOriented(tif, im->width, im->height, (uint32_t*)im->pData,
                                          /* ORIENTATION_TOPLEFT */ 1, 0))
            {
                unsigned int pixWidth = im->width * 4;
                unsigned int i;
                for (i = im->height - 1; i > 0; i--)
                {
                    memmove(im->pData + i * stride,
                            im->pData + i * pixWidth, pixWidth);
                }
            }
            else
                ret = SOFT_IMAGE_ERROR_DECODING;
        }
        else
            ret = SOFT_IMAGE_ERROR_MEMORY;
        TIFFClose(tif);
    }
    else
    {
        ret = SOFT_IMAGE_ERROR_FILE_OPEN;
    }
    return ret;
}

/**
 * Modified from: http://curl.haxx.se/libcurl/c/getinmemory.html
 * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
 * Distributed under: http://curl.haxx.se/docs/copyright.html
 **/

static void* libcurlHandle = NULL;
static void (*curl_global_init)(int);
static void* (*curl_easy_init)(void);
static void (*curl_easy_setopt)(void*, int, ...);
static int (*curl_easy_perform)(void*);
static void (*curl_easy_cleanup)(void*);
static void (*curl_global_cleanup)(void);

void unloadLibCurl()
{
    if (libcurlHandle)
        dlclose(libcurlHandle);
    libcurlHandle = NULL;
}

static int loadLibCurl()
{
    char* error = NULL;
    if (libcurlHandle == NULL)
    {

#ifdef LCURL_NAME
        if (strcmp(LCURL_NAME, "") != 0)
            libcurlHandle = dlopen(LCURL_NAME, RTLD_LAZY);
#endif
        if (!libcurlHandle)
            libcurlHandle = dlopen("libcurl.so.4", RTLD_LAZY);
        if (!libcurlHandle)
        {
            libcurlHandle = dlopen("libcurl.so", RTLD_LAZY);

            if (!libcurlHandle)
            {
                libcurlHandle = dlopen("libcurl.so.3", RTLD_LAZY);

                if (!libcurlHandle)
                    goto error;
            }
        }

        curl_global_init = dlsym(libcurlHandle, "curl_global_init");
        if ((error = dlerror()) != NULL)
            goto error;

        curl_easy_init = dlsym(libcurlHandle, "curl_easy_init");
        if ((error = dlerror()) != NULL)
            goto error;

        curl_easy_setopt = dlsym(libcurlHandle, "curl_easy_setopt");
        if ((error = dlerror()) != NULL)
            goto error;

        curl_easy_perform = dlsym(libcurlHandle, "curl_easy_perform");
        if ((error = dlerror()) != NULL)
            goto error;

        curl_easy_cleanup = dlsym(libcurlHandle, "curl_easy_cleanup");
        if ((error = dlerror()) != NULL)
            goto error;

        curl_global_cleanup = dlsym(libcurlHandle, "curl_global_cleanup");
        if ((error = dlerror()) != NULL)
            goto error;
    }
    return 0;
error:
    fprintf(stderr, "%s\n", error);
    unloadLibCurl();
    return 1;
}

struct MemoryStruct
{
    unsigned char* memory;
    size_t size;
};

static size_t WriteMemoryCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    size_t realsize = size * nmemb;
    struct MemoryStruct* mem = (struct MemoryStruct*)userp;

    mem->memory = realloc(mem->memory, mem->size + realsize);
    if (!mem->memory)
    {
        return 0;
    }

    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;

    return realsize;
}

unsigned char* getImageFromUrl(const char* url, size_t* size)
{
    void* curl_handle;
    int res;

    struct MemoryStruct chunk = {0};

    if (loadLibCurl() != 0)
    {
        return NULL;
    }

    (*curl_global_init)(/* CURL_GLOBAL_ALL */ 3);

    curl_handle = (*curl_easy_init)();

    (*curl_easy_setopt)(curl_handle, /* CURLOPT_URL */ 10002, url);

    (*curl_easy_setopt)(curl_handle, /* CURLOPT_WRITEFUNCTION */ 20011,
                        WriteMemoryCallback);

    (*curl_easy_setopt)(curl_handle, /* CURLOPT_WRITEDATA */ 10001, (void*)&chunk);

    (*curl_easy_setopt)(curl_handle, /* CURLOPT_USERAGENT */ 10018, "libcurl-agent/1.0");

    res = (*curl_easy_perform)(curl_handle);

    if (res != 0)
    {
        free(chunk.memory);
        chunk.memory = NULL;
        chunk.size = 0;
        fprintf(stderr, "libCurl returned error code %d\n", res);
    }

    *size = chunk.size;

    (*curl_easy_cleanup)(curl_handle);
    (*curl_global_cleanup)();

    return chunk.memory;
}