wave-png.cpp

Go to the documentation of this file.

/*
 * wave-png.cpp
 *
 * From: png.c -- png texture loader
 * http://tfcduke.developpez.com/tutoriel/format/png/
 *
 * last modification of that file: feb. 5, 2006
 * png.c Copyright (c) 2005-2006 David HENRY
 * wave-png.cpp Copyright(C) 2009  Thomas A. Vaughan
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

// includes --------------------------------------------------------------------
#include "wave-png.h"           // always include our own header first!

#include "png.h"                // libpng header

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

#include <fstream>

#include "nstream/nstream.h"
#include "perf/perf.h"
#include "util/file.h"



////////////////////////////////////////////////////////////////////////////////
//
//      This code from http://tfcduke.developpez.com/tutoriel/format/png/
//      file there: png.c   Thanks again to David Henry!
//
//      Main changes in wave-png.cpp vs png.c:
//       - Removed dependencies on OpenGL/glut
//       - Added support for reading from nstream::Stream and std::istream
//       - general style formatting (see wavepacket style, derived from FreeBSD)
//       - save to media::image_t object
//
////////////////////////////////////////////////////////////////////////////////



namespace media {


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
pngReadFromStream
(
png_structp ctx,
png_bytep data,
png_size_t bytes
)
{
        std::istream * pstream = (std::istream *) png_get_io_ptr(ctx);
        ASSERT(pstream, "null context");

//      DPRINTF("Asked to read %d bytes", (int) bytes);

        pstream->read((char *) data, bytes);
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

static int
getBytesPerPixel
(
IN int ct
)
throw()
{
        switch(ct) {
        case PNG_COLOR_TYPE_GRAY:       return 1;
        case PNG_COLOR_TYPE_GRAY_ALPHA: return 2;
        case PNG_COLOR_TYPE_RGB:        return 3;
        case PNG_COLOR_TYPE_RGB_ALPHA:  return 4;
        default:
                ASSERT_THROW(false, "unknown color type: " << ct);
        }
        return 0;
}



static eColorFormat
getColorFormat
(
IN int pngColorType
)
throw()
{
        switch (pngColorType) {
        case PNG_COLOR_TYPE_GRAY:       return eColorFormat_Grayscale;
        case PNG_COLOR_TYPE_GRAY_ALPHA: return eColorFormat_GrayAlpha;
        case PNG_COLOR_TYPE_RGB:        return eColorFormat_RGB;
        case PNG_COLOR_TYPE_RGB_ALPHA:  return eColorFormat_RGBA;
        default:
                ASSERT_THROW(false, "Unknown color type: " << pngColorType);
        }
        return eColorFormat_Invalid;
}



void
readPngFromStream
(
IO std::istream& stream,
OUT image_t& png
)
{
        perf::Timer timer("readPngFromStream");
        ASSERT_THROW(stream.good(), "bad stream?");
        png.clear();

        // read magic number
        const int magicBytes = 8;
        png_byte magic[magicBytes];
        stream.read((char *) magic, magicBytes);
        if (stream.eof() || stream.fail()) {
                DPRINTF("Stream had issues!");
        }
        if (!png_check_sig(magic, magicBytes)) {
                WAVE_EX(wex);
                wex << "Stream does not contain valid PNG header";
        }

        // create a png read struct
        png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
            NULL, NULL, NULL);
        ASSERT(png_ptr, "failed to create png read struct");

        // create a png info struct
        png_infop info_ptr = png_create_info_struct(png_ptr);
        ASSERT(info_ptr, "failed to create png info struct");

        // libpng uses setjmp/longjmp for errors
        // A longjmp will return here.  Clean up and throw.
        if (setjmp(png_jmpbuf(png_ptr))) {
                png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
                png.clear();
                WAVE_EX(wex);
                wex << "Encountered an error reading PNG from stream.";
                wex << "  Corrupted file?";
        }

        // we want to read from std::istream, so override the default read fn
        png_set_read_fn(png_ptr, &stream, pngReadFromStream);

        // we've got the magic number
        png_set_sig_bytes(png_ptr, magicBytes);

        // read png info
        png_read_info(png_ptr, info_ptr);
        // DPRINTF("width:  %d pixels", (int) info_ptr->width);
        // DPRINTF("height: %d pixels", (int) info_ptr->height);
        // DPRINTF("rowbytes: %d", (int) info_ptr->rowbytes);
        // DPRINTF("bit_depth: %d", info_ptr->bit_depth);
        // DPRINTF("color_type: %d", info_ptr->color_type);
        // DPRINTF("pixel_depth: %d", info_ptr->pixel_depth);

        // get info
        png.bit_depth = png_get_bit_depth(png_ptr, info_ptr);
        int pngColorType = png_get_color_type(png_ptr, info_ptr);
        png.color_format = getColorFormat(pngColorType);
        // DPRINTF("color_format: %d", png.color_format);

        // convert index color images to RGB
        if (PNG_COLOR_TYPE_PALETTE == pngColorType) {
                DPRINTF("Transforming from palette to rgb");
                png_set_palette_to_rgb(png_ptr);
        } else if (eColorFormat_Grayscale == png.color_format &&
                   png.bit_depth < 8) {
                DPRINTF("Transforming to 8-bit grayscale");
                png_set_gray_1_2_4_to_8(png_ptr);
        }

        if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
                DPRINTF("Doing weird tRNS thing");
                png_set_tRNS_to_alpha(png_ptr);
        }

        if (16 == png.bit_depth) {
                png_set_strip_16(png_ptr);
        } else if (png.bit_depth < 8) {
                png_set_packing(png_ptr);
        }

        // update for transformations (anything we did above)
        png_read_update_info(png_ptr, info_ptr);

        // bytes per pixel
        int bpp = getBytesPerPixel(info_ptr->color_type);
        ASSERT_THROW(bpp > 0 && bpp < 5,
            "Bad bytes per pixel: " << bpp);

        // update png object
        png.width = info_ptr->width;
        png.height = info_ptr->height;
        png.bytes_per_pixel = bpp;

        // ask for memory
        png.allocate();
        ASSERT_THROW(png.data, "failed");

        // read a row at a time
        // NOTE: read rows in reverse order!  PNG format is bottom-to-top
        long bytes_per_row = png.width * bpp;
        for (int i = 0; i < png.height; ++i) {
                long pixel_offset = png.height - i - 1;
                long byte_offset = pixel_offset * bytes_per_row;
                png_read_row(png_ptr, png.data + byte_offset, NULL);
        }

#ifdef DEBUG
        // DEBUG: write out the first NxN pixels
        {
                int nCols = 120;        // this many characters in a row
                int nCount = 0;
                if (1 == bpp) {
                        DPRINTF("Dumping image (grayscale values)");
                        nCount = nCols / 5;
                } else if (3 == bpp) {
                        DPRINTF("Dumping RGB image (r,g,b)");
                        nCount = nCols / 13;
                } else if (4 == bpp) {
                        DPRINTF("Dumping RGBA image (r,g,b,a)");
                        nCount = nCols / 17;
                }
                DPRINTF("  (dumping top left %d x %d pixels)", nCount, nCount);
                for (int y = 0; y < nCount; ++y) {
                        const byte_t * data = png.data + y * bytes_per_row;
                        for (int x = 0; x < nCount; ++x, data += bpp) {
                                if (1 == bpp) {
                                        fprintf(stderr, "  %03d", *data);
                                } else if (3 == bpp) {
                                        fprintf(stderr, "  %03d,%03d,%03d",
                                            data[0], data[1], data[2]);
                                } else if (4 == bpp) {
                                        fprintf(stderr, "  %03d,%03d,%03d,%03d",
                                            data[0], data[1], data[2], data[3]);
                                }
                        }
                        fprintf(stderr, "\n");
                }
        }
#endif  // DEBUG

        // all done
        png_read_end(png_ptr, NULL);
        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        png.setImageType("PNG");
}



class PngLoader : public media::ImageLoader {
public:
        ~PngLoader(void) throw() { }

        // media::ImageLoader class interface methods --------------------------
        const char * getLoaderName(void) const throw() { return "PNG"; }
        bool canLoadImage(IN nstream::Manager * mgr,
                                IN const char * name) const {
                        mgr = mgr;      // unused
                        ASSERT(name, "null");

                        const char * ext = GetExtension(name);
                        DPRINTF("Checking extension: '%s'", ext);
                        return !strcasecmp("png", ext);
                }

        void load(IN nstream::Stream * stream,
                                OUT image_t& image) const {
                        std::istream& input = stream->getStream();
                        readPngFromStream(input, image);
                }
};



smart_ptr<ImageLoader>
createPngImageLoader
(
void
)
{
        smart_ptr<ImageLoader> loader = new PngLoader;
        ASSERT(loader, "out of memory");

        return loader;
}



};      // media namespace