lib/image/format/png.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/config.h>
#include <libexplain/fclose.h>
#include <libexplain/fopen.h>
#include <libexplain/fread.h>
#include <libexplain/fwrite.h>
#include <libexplain/output.h>
#include <png.h>

#include <lib/image/format/png.h>


image_format_png::~image_format_png()
{
}


image_format_png::image_format_png(int a_width, int a_height) :
    image_format(a_width, a_height)
{
}


image_format_png::image_format_png(int a_width, int a_height, data_t *a_data) :
    image_format(a_width, a_height, a_data)
{
}


const char *
image_format_png::type_name(void)
    const
{
    return "PNG";
}


static void
input_read_glue(png_structp png_ptr, png_bytep data, png_size_t size)
{
  FILE *fp = (FILE *)png_get_io_ptr(png_ptr);
    size_t check = explain_fread_or_die(data, 1, size, fp);
    if (check != size)
        png_error(png_ptr, "Read Error");
}


image::pointer
image_format_png::create(const std::string &filename)
{
    //
    // open file and test for it being a png
    //
    FILE *fp = explain_fopen_or_die(filename.c_str(), "rb");
    png_byte header[4];
    explain_fread_or_die(header, sizeof(header), 1, fp);
    if (png_sig_cmp(header, 0, sizeof(header)))
        explain_output_error_and_die("%s: not a PNG file", filename.c_str());

    //
    // read the image from the file
    //
    png_structp png_ptr =
        png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (!png_ptr)
    {
        oops:
        explain_output_error_and_die("read %s: oops", filename.c_str());
    }

    // If you want to understand what is happening here, read the PNG
    // book "PNG The Definitive Guide" by Greg Roelofs.
    //
    // The relevant chapter is available online as
    // http://www.libpng.org/pub/png/book/chapter13.html
    //
    png_info *info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
        goto oops;

    if (setjmp(png_jmpbuf(png_ptr)))
    {
        explain_output_error_and_die("%s: error during init_io",
            filename.c_str());
    }

    png_set_read_fn(png_ptr, fp, input_read_glue);
    png_set_sig_bytes(png_ptr, sizeof(header));
    png_read_info(png_ptr, info_ptr);

    size_t width = png_get_image_width(png_ptr, info_ptr);
    assert(width >= 1);
    size_t height = png_get_image_height(png_ptr, info_ptr);
    assert(height >= 1);
    int color_type = png_get_color_type(png_ptr, info_ptr);
    int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
    assert(bit_depth >= 1);

    // force palette images to be expanded to 24-bit RGB.
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
        png_set_palette_to_rgb(png_ptr);
    }

    // low-bit-depth grayscale images are to be expanded to 8 bits
    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
    {
        png_set_expand_gray_1_2_4_to_8(png_ptr);
    }

    // expand any tRNS chunk data into a full alpha channel
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
    {
        png_set_tRNS_to_alpha(png_ptr);
    }

    // reduce images with 16-bit samples (e.g., 48-bit RGB) to 8 bits
    // per sample
    if (bit_depth == 16)
        png_set_strip_16(png_ptr);

    // expand grayscale images to RGB
    if
    (
        color_type == PNG_COLOR_TYPE_GRAY
    ||
        color_type == PNG_COLOR_TYPE_GRAY_ALPHA
    )
        png_set_gray_to_rgb(png_ptr);

    // Once we've registered all of our desired transformations, we
    // request that libpng update the information struct appropriately
    png_read_update_info(png_ptr, info_ptr);

    color_type = png_get_color_type(png_ptr, info_ptr);
    assert(color_type == PNG_COLOR_TYPE_RGB ||
        color_type == PNG_COLOR_TYPE_RGB_ALPHA);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);
    assert(bit_depth == 8);

    // read file
    if (setjmp(png_jmpbuf(png_ptr)))
    {
        explain_output_error_and_die("%s: error during read_image",
            filename.c_str());
    }

    size_t rgba_rowspan = width * 4;
    size_t png_rowbytes = png_get_rowbytes(png_ptr, info_ptr);
    size_t png_data_size = height * png_rowbytes;
    png_byte *png_data = new png_byte [png_data_size];
    png_byte **row_pointers = new png_byte * [height];
    for (size_t y = 0; y < height; ++y)
        row_pointers[y] = png_data + y * png_rowbytes;
    png_read_image(png_ptr, row_pointers);
    explain_fclose_or_die(fp);
    fp = 0;

    //
    // Turn it into continuous RGBA data
    //
    if (png_rowbytes != rgba_rowspan)
    {
        assert(color_type == PNG_COLOR_TYPE_RGB);
        size_t rgba_size = height * rgba_rowspan;
        data_t *rgba_data = new data_t [rgba_size];
        for (size_t y = 0; y < height; ++y)
        {
            data_t *rgba_row = rgba_data + y * rgba_rowspan;
            png_byte *png_row = row_pointers[y];
            for (size_t x = 0; x < width; ++x)
            {
                *rgba_row++ = *png_row++;
                *rgba_row++ = *png_row++;
                *rgba_row++ = *png_row++;
                *rgba_row++ = 255;
            }
        }
        delete [] png_data;
        png_data = rgba_data;
    }
    delete [] row_pointers;

    //
    // Finally, we have an image.
    //
    return pointer(new image_format_png(width, height, png_data));
}


static void
output_write_glue(png_structp png_ptr, png_bytep data, png_size_t size)
{
  FILE *fp = (FILE *)png_get_io_ptr(png_ptr);
    explain_fwrite_or_die(data, 1, size, fp);
}


bool
image_format_png::calc_needs_alpha(void)
    const
{
    for (unsigned y = 0; y < get_height(); ++y)
    {
        png_byte *p = (png_byte *)get_data(y);
        for (unsigned x = 0; x < get_width(); ++x, p += 4)
        {
            if (p[3] != 255)
                return true;
        }
    }
    return false;
}


bool
image_format_png::calc_needs_rgb(void)
    const
{
    for (unsigned y = 0; y < get_height(); ++y)
    {
        png_byte *p = (png_byte *)get_data(y);
        for (unsigned x = 0; x < get_width(); ++x, p += 4)
        {
            if (p[3] != 0 && (p[0] != p[1] || p[0] != p[2]))
                return true;
        }
    }
    return false;
}


void
image_format_png::save_to_file(const std::string &filename)
    const
{
    //
    // create file
    //
    FILE *fp = explain_fopen_or_die(filename.c_str(), "wb");

    // initialize stuff
    png_structp png_ptr =
        png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
    if (!png_ptr)
    {
        oops:
        explain_output_error_and_die
        (
            "%s: oops, write failed",
            filename.c_str()
        );
    }
    png_info *info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
        goto oops;
    if (setjmp(png_jmpbuf(png_ptr)))
    {
        explain_output_error_and_die
        (
            "%s: errror during init_io",
            filename.c_str()
        );
    }
    png_set_write_fn(png_ptr, fp, output_write_glue, 0);

    // write header
    if (setjmp(png_jmpbuf(png_ptr)))
    {
        explain_output_error_and_die
        (
            "%s: error writing header",
            filename.c_str()
        );
    }

    bool needs_alpha = calc_needs_alpha();
    bool needs_rgb = calc_needs_rgb();
    int color_type =
        (
            needs_rgb
        ?
            (needs_alpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB)
        :
            (needs_alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY)
        );
    png_set_IHDR(png_ptr, info_ptr, get_width(), get_height(),
                 8, color_type, PNG_INTERLACE_NONE,
                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
    png_write_info(png_ptr, info_ptr);

    // write bytes
    if (setjmp(png_jmpbuf(png_ptr)))
    {
        explain_output_error_and_die
        (
            "%s: error writing bytes",
            filename.c_str()
        );
    }
    if (needs_rgb)
    {
        if (needs_alpha)
        {
            png_byte **row_pointers = new png_byte * [get_height()];
            for (size_t y = 0; y < get_height(); ++y)
                row_pointers[y] = (png_byte *)get_data(y);
            png_write_image(png_ptr, row_pointers);
            delete [] row_pointers;
        }
        else
        {
            png_byte *ob_base = new png_byte [get_width() * 3];
            for (unsigned y = 0; y < get_height(); ++y)
            {
                png_byte *ob = ob_base;
                png_byte *ib = (png_byte *)get_data(y);
                for (unsigned x = 0; x < get_width(); ++x, ib += 4)
                {
                    *ob++ = ib[0];
                    *ob++ = ib[1];
                    *ob++ = ib[2];
                }
                png_write_row(png_ptr, ob_base);
            }
            delete ob_base;
        }
    }
    else
    {
        if (needs_alpha)
        {
            png_byte *ob_base = new png_byte [get_width() * 2];
            for (unsigned y = 0; y < get_height(); ++y)
            {
                png_byte *ob = ob_base;
                png_byte *ib = (png_byte *)get_data(y);
                for (unsigned x = 0; x < get_width(); ++x, ib += 4)
                {
                    *ob++ = ib[0];
                    *ob++ = ib[3];
                }
                png_write_row(png_ptr, ob_base);
            }
            delete ob_base;
        }
        else
        {
            png_byte *ob_base = new png_byte [get_width()];
            for (unsigned y = 0; y < get_height(); ++y)
            {
                png_byte *ob = ob_base;
                png_byte *ib = (png_byte *)get_data(y);
                for (unsigned x = 0; x < get_width(); ++x, ib += 4)
                {
                    *ob++ = ib[0];
                }
                png_write_row(png_ptr, ob_base);
            }
            delete ob_base;
        }
    }

    // end write
    if (setjmp(png_jmpbuf(png_ptr)))
        explain_output_error_and_die("%s: error finishing", filename.c_str());
    png_write_end(png_ptr, NULL);

    explain_fclose_or_die(fp);
}


image::pointer
image_format_png::create_blank(int width, int height)
{
    return pointer(new image_format_png(width, height));
}