pgmppm.cpp

Go to the documentation of this file.

/*
 * pgmppm.cpp
 *
 * Copyright (C) 2008  Thomas A. Vaughan
 * 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 <organization> 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 THOMAS A. VAUGHAN ''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 THOMAS A. VAUGHAN 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.
 *
 *
 * Implementation of PGM/PPM routines.
 * See pgmppm.h
 *
 * Also see http://netpbm.sourceforge.net/doc/pgm.html
 */

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

#include "common/wave_ex.h"

#include "perf/perf.h"

#include "util/token_stream.h"


namespace pgmppm {


// constants
static const int s_maxGray              = 256;
static const int s_maxColor             = 256;

static const char * s_magicPGM          = "P5";
static const char * s_magicPPM          = "P6";


////////////////////////////////////////////////////////////////////////////////
//
//      public API: file writing
//
////////////////////////////////////////////////////////////////////////////////

void
writePgm
(
IO std::ostream& out,
IN int width,
IN int height,
IN int max_gray,
IN pgm_pixel_fn fn,
IN void * context
)
{
        perf::Timer timer("pgmppm::writePgm");
        ASSERT(out.good(), "bad?");
        ASSERT(width > 0, "bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);
        ASSERT(max_gray > 0 && max_gray < s_maxGray, "bad max_gray: %d",
            max_gray);
        ASSERT(fn, "null pgm callback");
        // ASSERT(context) -- we don't care

        int bpv = 0;            // bytes per value
        if (max_gray < 256) {
                bpv = 1;
        } else if (max_gray < 65536) {
                bpv = 2;
        } else {
                ASSERT(false, "Bad max_gray?");
        }
        ASSERT(bpv > 0, "Bad bytes per value: %d", bpv);

        // PGM header
        out << s_magicPGM << "\n";
        out << width << " " << height << "\n";
        out << max_gray << "\n";

        // raw data
        for (int j = 0; j < height; ++j) {
                for (int i = 0; i < width; ++i) {
                        int val = fn(context, i, j);

                        ASSERT(val >= 0 && val <= max_gray,
                           "Bad pixel value [%d, %d] = %d", i, j, val);

                        // for now, all other programs only work with 8-bit!
                        out.put((byte_t) val);

/*
                        byte_t * p = (byte_t *) &val;
                        p += bpv - 1;
                        for (int k = 0; k < bpv; ++k) {
                                out.write((const char *) p, 1);
                                --p;
                        }
 */
                }
        }
}



void
writePpm
(
IO std::ostream& out,
IN int width,
IN int height,
IN int max_color,
IN ppm_pixel_fn fn,
IN void * context
)
{
        perf::Timer timer("pgmppm::writePpm");
        ASSERT(out.good(), "bad?");
        ASSERT(width > 0, "Bad width: %d", width);
        ASSERT(height > 0, "bad height: %d", height);
        ASSERT(max_color > 0 && max_color < s_maxColor, "Bad max_color: %d",
            max_color);
        ASSERT(fn, "null ppm callback");
        // ASSERT(context) -- we don't care

        // PPM header
        out << s_magicPPM << "\n";
        out << width << " " << height << "\n";
        out << max_color << "\n";

        for (int j = 0; j < height; ++j) {
                for (int i = 0; i < width; ++i) {
                        color_t c = fn(context, i, j);
                        ASSERT(c.red >= 0 && c.red <= max_color,
                            "bad red val: %d", c.red);
                        ASSERT(c.green >= 0 && c.green <= max_color,
                            "bad green val: %d", c.green );
                        ASSERT(c.blue >= 0 && c.blue <= max_color,
                            "bad blue val: %d", c.blue );

                        out.put((byte_t) c.red);
                        out.put((byte_t) c.green);
                        out.put((byte_t) c.blue);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      file reading
//
////////////////////////////////////////////////////////////////////////////////

bool
readPgm
(
IO std::istream& in,
IN notify_size_fn notify,
IN pgm_write_pixel_fn write_pixel,
IN void * context
)
{
        perf::Timer timer("pgmppm::readPgm");
        ASSERT(in.good(), "bad?");
        ASSERT(notify, "null");
        ASSERT(write_pixel, "null");
        // ASSERT(context) - we don't care

        std::string token;
        expectToken(in, s_magicPGM);

        int width = readInteger(in, token);
        int length = readInteger(in, token);
        if (width <= 0 || length <= 0) {
                WAVE_EX(wex);
                wex << "Bad width (" << width << ") ";
                wex << "or length (" << length << ")";
        }
        
        int max_val = readInteger(in, token);
        if (max_val <= 0 || max_val >= s_maxGray) {
                WAVE_EX(wex);
                wex << "Unsupported max_gray: " << max_val;
        }

        DPRINTF("Reading PGM of dimensions %d x %d, max_gray = %d",
            width, length, max_val);
        if (!notify(context, width, length, max_val))
                return false;

        for (int j = 0; j < length; ++j) {
                for (int i = 0; i < width; ++i) {
                        char c;
                        if (!in.good()) {
                                WAVE_EX(wex);
                                wex << "Could not read entire pgm image";
                        }
                        in.get(c);
                        byte_t b = c;
                        write_pixel(context, i, j, b);
                }
        }

        return true;
}



};      // pgmppm namespace