jiff.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc/config.h>

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <inttypes.h>

#include "jwsc/base/bits.h"
#include "jwsc/image/jiff.h"

#ifdef JWSC_HAVE_DMALLOC
#include <dmalloc.h>
#endif


#define  HEADER_SIZE              64

#define  DEFAULT_JIFF_COLORSPACE  JIFF_RGB

#define  DEFAULT_JIFF_DEPTH       JIFF_8_BIT

#define  DEFAULT_JIFF_TYPE        JIFF_INTEGER

#define  DEFAULT_JIFF_RED_W       0.3f

#define  DEFAULT_JIFF_GREEN_W     0.59f

#define  DEFAULT_JIFF_BLUE_W      0.11f


void init_jiff_attributes(JIFF_attributes* attrs)
{
    attrs->colorspace = DEFAULT_JIFF_COLORSPACE;
    attrs->depth      = DEFAULT_JIFF_DEPTH;
    attrs->type       = DEFAULT_JIFF_TYPE;
    attrs->red_w      = DEFAULT_JIFF_RED_W;
    attrs->green_w    = DEFAULT_JIFF_GREEN_W;
    attrs->blue_w     = DEFAULT_JIFF_BLUE_W;
}




Error* read_image_as_jiff_f(Image_f** img_out, const char* fname)
{
    FILE* fp;

    uint32_t header[HEADER_SIZE];
#ifndef JWSC_BIGENDIAN
    uint32_t i;
#endif

    uint32_t num_rows;
    uint32_t num_cols;

    uint32_t num_channels;
    uint32_t channel_bytes;

    void*     data;
    float*    elts;
    uint32_t  num_elts;
    uint32_t  elt;
    Pixel_f*  pxls;

    JIFF_attributes attrs;


    if (!(fp = fopen(fname, "r")))
    {
        free_image_f(*img_out); *img_out = NULL;
        return JWSC_EIO("Could not open jiff file");
    }

    if (fread(header, 4, HEADER_SIZE, fp) != HEADER_SIZE)
    {
        fclose(fp);
        free_image_f(*img_out); *img_out = NULL;
        return JWSC_EIO("Could not read jiff header");
    }

#ifndef JWSC_BIGENDIAN
    for (i = 0; i < HEADER_SIZE; i++)
    {
        bswap_u32(&(header[ i ]));
    }
#endif

    num_rows = header[0];
    num_cols = header[1];

    /* Colorspace */
    switch (header[2])
    {
        case JIFF_RGB:
            attrs.colorspace = JIFF_RGB;
            num_channels = 3;
            break;
        case JIFF_GRAY:
            attrs.colorspace = JIFF_GRAY;
            num_channels = 1;
            break;
        default:
            fclose(fp);
            free_image_f(*img_out); *img_out = NULL;
            return JWSC_EIO("Unknown JIFF colorspace");
    }

    /* Depth */
    switch (header[3])
    {
        case JIFF_8_BIT:
            attrs.depth = JIFF_8_BIT;
            channel_bytes = 1;
            break;
        case JIFF_16_BIT:
            attrs.depth = JIFF_16_BIT;
            channel_bytes = 2;
            break;
        case JIFF_32_BIT:
            attrs.depth = JIFF_32_BIT;
            channel_bytes = 4;
            break;
        default:
            fclose(fp);
            free_image_f(*img_out); *img_out = NULL;
            return JWSC_EIO("Unknown JIFF channel depth");
    }

    /* Type */
    switch (header[4])
    {
        case JIFF_INTEGER:
            attrs.type = JIFF_INTEGER;
            break;
        case JIFF_FLOAT:
            if (attrs.depth != JIFF_32_BIT)
            {
                fclose(fp);
                free_image_f(*img_out); *img_out = NULL;
                return JWSC_EIO("Invalid JIFF channel type for depth");
            }
            attrs.type = JIFF_FLOAT;
            break;
        default:
            fclose(fp);
            free_image_f(*img_out); *img_out = NULL;
            return JWSC_EIO("Unknown JIFF channel type");
    }

    num_elts = num_rows*num_cols*num_channels;
    assert(data = malloc(channel_bytes*num_elts));

    if (fread(data, channel_bytes, num_elts, fp) != num_elts)
    {
        free(data);
        fclose(fp);
        free_image_f(*img_out); *img_out = NULL;
        return JWSC_EIO("Could not read jiff data");
    }

#ifndef JWSC_BIGENDIAN
    if (attrs.depth != JIFF_8_BIT)
    {
        for (elt = 0; elt < num_elts; elt++)
        {
            switch(attrs.depth)
            {
                case JIFF_16_BIT:
                    bswap_u16(&(((uint16_t*)data)[ elt ]));
                    break;
                case JIFF_32_BIT:
                    bswap_u32(&(((uint32_t*)data)[ elt ]));
                    break;
                default:
                    abort();
            }
        }
    }
#endif

    create_image_f(img_out, num_rows, num_cols);
    elts = (float*)*((*img_out)->pxls);
    pxls = *((*img_out)->pxls);

    if (attrs.colorspace == JIFF_RGB)
    {
        for (elt = 0; elt < num_elts; elt += 3)
        {
            if (attrs.type == JIFF_FLOAT)
            {
                elts[ elt+0 ] = ((float*)data)[ elt+0 ];
                elts[ elt+1 ] = ((float*)data)[ elt+1 ];
                elts[ elt+2 ] = ((float*)data)[ elt+2 ];
            }
            else if (attrs.depth == JIFF_8_BIT)
            {
                elts[ elt+0 ] = (float)((uint8_t*)data)[ elt+0 ] / 0xFF;
                elts[ elt+1 ] = (float)((uint8_t*)data)[ elt+1 ] / 0xFF;
                elts[ elt+2 ] = (float)((uint8_t*)data)[ elt+2 ] / 0xFF;
            }
            else if (attrs.depth == JIFF_16_BIT)
            {
                elts[ elt+0 ] = (float)((uint16_t*)data)[ elt+0 ] / 0xFFFF;
                elts[ elt+1 ] = (float)((uint16_t*)data)[ elt+1 ] / 0xFFFF;
                elts[ elt+2 ] = (float)((uint16_t*)data)[ elt+2 ] / 0xFFFF;
            }
            else if (attrs.depth == JIFF_32_BIT)
            {
                elts[ elt+0 ] = (float)((uint32_t*)data)[ elt+0 ] / 0xFFFFFFFF;
                elts[ elt+1 ] = (float)((uint32_t*)data)[ elt+1 ] / 0xFFFFFFFF;
                elts[ elt+2 ] = (float)((uint32_t*)data)[ elt+2 ] / 0xFFFFFFFF;
            }
            else
            {
                abort();
            }
        }
    }
    else if (attrs.colorspace == JIFF_GRAY)
    {
        for (elt = 0; elt < num_elts; elt++)
        {
            if (attrs.type == JIFF_FLOAT)
            {
                pxls[ elt ].r = ((float*)data)[ elt ];
                pxls[ elt ].g = ((float*)data)[ elt ];
                pxls[ elt ].b = ((float*)data)[ elt ];
            }
            else if (attrs.depth == JIFF_8_BIT)
            {
                pxls[ elt ].r = (float)((uint8_t*)data)[ elt ] / 0xFF;
                pxls[ elt ].g = (float)((uint8_t*)data)[ elt ] / 0xFF;
                pxls[ elt ].b = (float)((uint8_t*)data)[ elt ] / 0xFF;
            }
            else if (attrs.depth == JIFF_16_BIT)
            {
                pxls[ elt ].r = (float)((uint16_t*)data)[ elt ] / 0xFFFF;
                pxls[ elt ].g = (float)((uint16_t*)data)[ elt ] / 0xFFFF;
                pxls[ elt ].b = (float)((uint16_t*)data)[ elt ] / 0xFFFF;
            }
            else if (attrs.depth == JIFF_32_BIT)
            {
                pxls[ elt ].r = (float)((uint32_t*)data)[ elt ] / 0xFFFFFFFF;
                pxls[ elt ].g = (float)((uint32_t*)data)[ elt ] / 0xFFFFFFFF;
                pxls[ elt ].b = (float)((uint32_t*)data)[ elt ] / 0xFFFFFFFF;
            }
            else
            {
                abort();
            }
        }
    }
    else
    {
        abort();
    }

    free(data);
    fclose(fp);

    return NULL;
}

Error* write_image_as_jiff_f
(
    const Image_f*         img, 
    const char*            fname, 
    const JIFF_attributes* attrs
)
{
    FILE* fp;

    uint32_t header[HEADER_SIZE] = {0};
    uint32_t num_elts;
    uint32_t elt;
    uint32_t num_channels;
    uint32_t channel_bytes;
#ifndef JWSC_BIGENDIAN
    uint32_t i;
#endif

    float gray;
    float red, green, blue;

    void*     data;
    float*    elts;
    Pixel_f*  pxls;


    if (attrs->type == JIFF_FLOAT && attrs->depth != JIFF_32_BIT)
    {
        return JWSC_EIO("Invalid JIFF channel type for depth");
    }


    /* Prepare the header. */
    header[0] = img->num_rows;
    header[1] = img->num_cols;
    header[2] = attrs->colorspace;
    header[3] = attrs->depth;
    header[4] = attrs->type;

#ifndef JWSC_BIGENDIAN
    for (i = 0; i < HEADER_SIZE; i++)
    {
        bswap_u32(&(header[ i ]));
    }
#endif

    /* Prepare the data. */
    switch (attrs->colorspace)
    {
        case JIFF_RGB:
            num_channels = 3;
            break;
        case JIFF_GRAY:
            num_channels = 1;
            break;
        default:
            abort();
    }

    switch (attrs->depth)
    {
        case JIFF_8_BIT:
            channel_bytes = 1;
            break;
        case JIFF_16_BIT:
            channel_bytes = 2;
            break;
        case JIFF_32_BIT:
            channel_bytes = 4;
            break;
        default:
            abort();
    }
    
    num_elts = img->num_rows*img->num_cols*num_channels;
    assert(data = malloc(channel_bytes*num_elts));

    elts = (float*)*(img->pxls);
    pxls = *(img->pxls);

    if (attrs->colorspace == JIFF_RGB)
    {
        for (elt = 0; elt < num_elts; elt += 3)
        {
            red   = elts[ elt+0 ];
            green = elts[ elt+1 ];
            blue  = elts[ elt+2 ];

            if (attrs->type == JIFF_FLOAT)
            {
                ((float*)data)[ elt+0 ] = red;
                ((float*)data)[ elt+1 ] = green;
                ((float*)data)[ elt+2 ] = blue;
            }
            else if (attrs->depth == JIFF_8_BIT)
            {
                ((uint8_t*)data)[ elt+0 ] = (uint8_t)(red * 0xFF);
                ((uint8_t*)data)[ elt+1 ] = (uint8_t)(green * 0xFF);
                ((uint8_t*)data)[ elt+2 ] = (uint8_t)(blue * 0xFF);
            }
            else if (attrs->depth == JIFF_16_BIT)
            {
                ((uint16_t*)data)[ elt+0 ] = (uint16_t)(red * 0xFFFF);
                ((uint16_t*)data)[ elt+1 ] = (uint16_t)(green * 0xFFFF);
                ((uint16_t*)data)[ elt+2 ] = (uint16_t)(blue * 0xFFFF);
            }
            else if (attrs->depth == JIFF_32_BIT)
            {
                ((uint32_t*)data)[ elt+0 ] = (uint32_t)(red * 0xFFFFFFFF);
                ((uint32_t*)data)[ elt+1 ] = (uint32_t)(green * 0xFFFFFFFF);
                ((uint32_t*)data)[ elt+2 ] = (uint32_t)(blue * 0xFFFFFFFF);
            }
            else
            {
                abort();
            }
        }
    }
    else if (attrs->colorspace == JIFF_GRAY)
    {
        for (elt = 0; elt < num_elts; elt++)
        {
            gray = attrs->red_w   * pxls[ elt ].r + 
                   attrs->green_w * pxls[ elt ].g + 
                   attrs->blue_w  * pxls[ elt ].b;

            if (attrs->type == JIFF_FLOAT)
            {
                ((float*)data)[ elt ]  = gray;
            }
            else if (attrs->depth == JIFF_8_BIT)
            {
                ((uint8_t*)data)[ elt ]  = (uint8_t)(gray * 0xFF);
            }
            else if (attrs->depth == JIFF_16_BIT)
            {
                ((uint16_t*)data)[ elt ]  = (uint16_t)(gray * 0xFFFF);
            }
            else if (attrs->depth == JIFF_32_BIT)
            {
                ((uint32_t*)data)[ elt ]  = (uint32_t)(gray * 0xFFFFFFFF);
            }
            else
            {
                abort();
            }
        }
    }
    else
    {
        abort();
    }

#ifndef JWSC_BIGENDIAN
    if (attrs->depth != JIFF_8_BIT)
    {
        for (elt = 0; elt < num_elts; elt++)
        {
            switch(attrs->depth)
            {
                case JIFF_16_BIT:
                    bswap_u16(&(((uint16_t*)data)[ elt ]));
                    break;
                case JIFF_32_BIT:
                    bswap_u32(&(((uint32_t*)data)[ elt ]));
                    break;
                default:
                    abort();
            }
        }
    }
#endif


    if (!(fp = fopen(fname, "w")))
    {
        free(data);
        return JWSC_EIO("Could not open jiff file");
    }

    if (fwrite(header, 4, HEADER_SIZE, fp) != HEADER_SIZE)
    {
        free(data);
        fclose(fp);
        return JWSC_EIO("Could not write jiff header");
    }

    if (fwrite(data, channel_bytes, num_elts, fp) != num_elts)
    {
        free(data);
        fclose(fp);
        return JWSC_EIO("Could not write jiff data");
    }

    free(data);
    fclose(fp);

    return NULL;
}