/* This file is part of dvi2bitmap; see README for copyrights and licence */
#include <config.h>
#include <iostream> // debug code writes to cerr
#include <time.h>
#include <assert.h>
#if HAVE_CSTD_INCLUDE
#include <cstdio>
#include <cmath> // for floor()
#else
#include <stdio.h>
#include <math.h> // for floor()
#endif
#include "Bitmap.h" // for BitmapError exception class
#include "PNGBitmap.h"
using STD::fopen;
using STD::fclose;
using STD::cerr;
// The PNG calls below have been written to be general, rather than
// depending on a particular colour model. That is, it should be
// possible to define colour_type in write() to be PNG_COLOR_TYPE_GRAY
// instead of the current PNG_COLOR_TYPE_PALETTE, and for the rest of
// the routine to simply work. This requires the function
// png_set_write_user_transform_fn to be in libpng, which is true only
// of versions of the library after 0.96. Having said that, it hasn't
// been tested recently. The following define is really intended only to
// document the points which would need attention if the colour model
// were to be generalised in future: if you were to define it to be 1
// the write() routine would probably work, but I'm not guaranteeing anything.
#define GREYSCALE_BITMAP 0
png_structp PNGBitmap::png_ptr_ = 0;
png_infop PNGBitmap::info_ptr_ = 0;
// Following two must have indexes 1..8 (for up to 8 bpp bit depth),
// be initialised to zero, and have the same length.
// Static, so not deleted in destructor.
png_color *PNGBitmap::palettes_[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
png_byte *PNGBitmap::trans_[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
#if GREYSCALE_BITMAP
static void png_invert_greyscale (png_structp png_ptr,
png_row_infop row_info,
png_bytep data);
#endif
PNGBitmap::PNGBitmap (const int w, const int h, const int bpp)
: BitmapImage (w, h, bpp)
{
}
PNGBitmap::~PNGBitmap()
{
if (png_ptr_ != 0)
png_destroy_write_struct (&png_ptr_, (!info_ptr_ ? 0 : &info_ptr_));
/*
int npalettes = sizeof(palettes_)/sizeof(palettes_[0]);
for (int i=0; i<npalettes; i++)
{
if (palettes_[i] != 0)
delete[] palettes_[i];
if (trans_[i] != 0)
// Won't necessarily be non-zero when palettes_[i] is, if
// isTransparent_ is true.
delete[] trans_[i];
}
*/
}
inline int iround (float f)
{
return static_cast<int>(f>0 ? floor(f+0.5) : ceil(f-0.5));
}
void PNGBitmap::write (const string filename)
{
// Write out bitmaps using a palette. A greyscale is more
// obvious, since the smoothed bit values are essentially
// monochrome, but using a palette (a) makes it very easy to use
// colours different from black in the future, and (b) allows us
// to use a tRNS chunk to include transparency information,
// without the overhead of a full alpha channel. Palettes are
// limited to 8 bits of colour table.
// This routine can cope with only these two types
#if GREYSCALE_BITMAP
int colour_type = PNG_COLOR_TYPE_GRAY;
#else
int colour_type = PNG_COLOR_TYPE_PALETTE;
#endif
if (bitmapRows_ != h_)
throw BitmapError ("attempt to PNGBitmap::write with incomplete bitmap");
// Can't cope with bit depths greater than 8. The library can
// cope with depths of 16, too, but then I'd probably have to
// rewrite png_invert_greyscale()
if (bpp_ > 8)
throw BitmapError ("can't presently cope with bit depths greater than 8");
FILE *pngfile = fopen (filename.c_str(), "wb");
if (!pngfile)
throw BitmapError ("Can't open file "+filename+" to write");
if (png_ptr_ == 0) // allocate and initialise
{
// Use default error handlers for now
png_ptr_ = png_create_write_struct
(PNG_LIBPNG_VER_STRING,
0,
static_cast<png_error_ptr>(&png_error_fn),
static_cast<png_error_ptr>(&png_warning_fn));
if (! png_ptr_)
{
fclose (pngfile);
throw BitmapError ("Can't create png_ptr");
}
info_ptr_ = png_create_info_struct (png_ptr_);
if (! info_ptr_)
{
png_destroy_write_struct (&png_ptr_, 0);
fclose (pngfile);
throw BitmapError ("Can't create PNG info_ptr");
}
#if GREYSCALE_BITMAP
// Call png_set_write_user_transform_fn to install a function
// to invert the greyscale on output. This function is not
// present in libpng 0.96 -- should I work around this or just
// require newer versions?
if (colour_type == PNG_COLOR_TYPE_GRAY)
png_set_write_user_transform_fn (png_ptr_, &png_invert_greyscale);
#endif
/* not needed since I use custom error functions above
if (setjmp (png_ptr_->jmpbuf))
{
png_destroy_write_struct (&png_ptr_, &info_ptr_);
fclose (pngfile);
throw BitmapError ("libpng internal error");
}
*/
}
// Set up output code
png_init_io (png_ptr_, pngfile);
// find the first power-of-two bitdepth not less than bpp_
assert (bpp_ <= 16); // following loop will terminate
int png_bitdepth;
for (png_bitdepth = 1; png_bitdepth < bpp_; png_bitdepth *= 2)
;
if (verbosity_ > normal)
cerr << "Initialising png_set_IHDR: w="<<w_
<< " h=" << h_
<< " bpp=" << bpp_
<< " png_bitdepth=" << png_bitdepth
<< "\n";
png_set_IHDR (png_ptr_, info_ptr_, w_, h_, png_bitdepth,
colour_type,
PNG_INTERLACE_ADAM7,
PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
if (colour_type & PNG_COLOR_MASK_PALETTE)
{
if (palettes_[bpp_] == 0
|| (isTransparent_ && trans_[bpp_] == 0))
{
// Create and set palette, making a smooth palette between
// 0..(2^bpp_-1). Note that the input bitmap is coded in
// terms of high=black, so invert this in this palette.
int maxcolour = (1<<bpp_)-1;
int diffred = fg_.red - bg_.red;
int diffgreen = fg_.green - bg_.green;
int diffblue = fg_.blue - bg_.blue;
palettes_[bpp_] = new png_color[maxcolour+1];
if (isTransparent_)
trans_[bpp_] = new png_byte[maxcolour+1];
for (int i=0; i<=maxcolour; i++)
{
float rat = static_cast<float>(i)/maxcolour;
if (isTransparent_)
{
// A linear alpha function (iround(rat*255)) is
// the obvious thing here, but when an image is
// displayed against a white background, this
// effectively makes the palette quadratic, and so
// makes the image look very jaggy.
//
// Given foreground colour f, background colour b,
// and rat in [0,1], we want the resulting
// intensity to be I=p_0=b+rat(f-b), as in the
// non-alpha case. With an alpha function a, and
// palette p_a, displayed against a background of
// colour b, I suppose we'll have I=(1-a)b+a p_a
// (yes?), which equals p_0 if p_a=b+rat/a(f-b).
// So choosing an alpha function a=sqrt(rat) makes
// p_a=b+sqrt(rat)(f-b).
//
// Note that this shows that transparency
// information is optimal for only one background
// colour.
//trans_[bpp_][i] = iround (rat*255);
float sqrat = sqrt(rat);
trans_[bpp_][i] = iround (sqrat*255);
palettes_[bpp_][i].red
= iround (bg_.red + sqrat*diffred);
palettes_[bpp_][i].green
= iround (bg_.green + sqrat*diffgreen);
palettes_[bpp_][i].blue
= iround (bg_.blue + sqrat*diffblue);
}
else
{
palettes_[bpp_][i].red
= bg_.red + iround(rat*diffred);
palettes_[bpp_][i].green
= bg_.green + iround(rat*diffgreen);
palettes_[bpp_][i].blue
= bg_.blue + iround(rat*diffblue);
}
}
if (verbosity_ > debug)
{
cerr << "Allocated palette for bitdepth " << bpp_
<< "...\n";
for (int i=0; i<=maxcolour; i++)
cerr << '\t' << i
<< '\t'
<< static_cast<int>(palettes_[bpp_][i].red)
<< '\t'
<< static_cast<int>(palettes_[bpp_][i].green)
<< '\t'
<< static_cast<int>(palettes_[bpp_][i].blue)
<< '\t'
<< static_cast<int>(isTransparent_
? trans_[bpp_][i]
: -1)
<< '\n';
}
}
assert (palettes_[bpp_] != 0);
assert (!isTransparent_ || (trans_[bpp_] != 0));
png_set_PLTE (png_ptr_, info_ptr_,
palettes_[bpp_], (1<<bpp_));
if (isTransparent_)
png_set_tRNS (png_ptr_, info_ptr_,
trans_[bpp_], (1<<bpp_),
0);
// Fill in the bKGD chunk, just for completeness.
// This definition of the background colour is suitable for
// different colour models: colour index 0 is the background
// colour by construction, above.
png_color_16 bKGD_colour;
bKGD_colour.index = 0;
bKGD_colour.red = bg_.red;
bKGD_colour.green = bg_.green;
bKGD_colour.blue = bg_.blue;
png_set_bKGD (png_ptr_, info_ptr_, &bKGD_colour);
}
time_t sectime = time(0);
if (sectime >= 0)
{
png_time pngtime;
png_convert_from_time_t (&pngtime, sectime);
png_set_tIME (png_ptr_, info_ptr_, &pngtime);
}
png_text text_fields[3];
unsigned int nfields = 0;
if (softwareversion != 0)
{
text_fields[nfields].key = const_cast<char *>("Software");
text_fields[nfields].text
= const_cast<char*>(softwareversion->c_str());
text_fields[nfields].text_length = strlen (text_fields[nfields].text);
text_fields[nfields].compression = PNG_TEXT_COMPRESSION_NONE;
nfields++;
}
string t1, t2;
if (inputfilename != 0)
{
text_fields[nfields].key = const_cast<char *>("Comment");
t1.assign ("Converted from DVI file ");
t1 += *inputfilename;
text_fields[nfields].text = const_cast<char*>(t1.c_str());
text_fields[nfields].text_length = t1.length();
text_fields[nfields].compression = PNG_TEXT_COMPRESSION_NONE;
nfields++;
}
if (furtherinfo != 0)
{
text_fields[nfields].key = const_cast<char *>("Comment");
t2.assign ("See ");
t2 += *furtherinfo;
text_fields[nfields].text = const_cast<char*>(t2.c_str());
text_fields[nfields].text_length = t2.length();
text_fields[nfields].compression = PNG_TEXT_COMPRESSION_NONE;
nfields++;
}
assert (nfields <= sizeof(text_fields)/sizeof(text_fields[0]));
if (nfields > 0)
png_set_text (png_ptr_, info_ptr_, text_fields, nfields);
png_write_info (png_ptr_, info_ptr_);
// data is supplied one pixel per byte: tell libpng this
png_set_packing (png_ptr_);
// PNG can handle bit depths of 1, 2, 4, 8, and 16, but this
// routine can be given bit depths other than these. If this is
// the case (so that png_bitdepth will have been set different
// from bpp_ above), then log this
// by writing an sBIT chunk, and (importantly) also call
// png_set_shift to tell libpng to scale the bits.
if (png_bitdepth != bpp_)
{
png_color_8 sigbit;
if (colour_type & PNG_COLOR_MASK_COLOR)
sigbit.red
= sigbit.green
= sigbit. blue
= bpp_;
else
sigbit.gray = bpp_;
if (colour_type & PNG_COLOR_MASK_ALPHA)
sigbit.alpha = bpp_;
png_set_sBIT (png_ptr_, info_ptr_, &sigbit);
png_set_shift (png_ptr_, &sigbit);
}
// Now write the image. png_write_image requires an array of
// pointers to rows in the bitmap. Create this here, possibly
// after (re)allocating the array. The RowPointer typedef is here
// partly to document the intention, but also because some
// compilers (legitimately?) object to `new (const Byte*)[rows_alloc]'.
typedef const Byte* RowPointer;
static RowPointer *rows;
static int rows_alloc = -1; // rely on this being initialised
// negative, and specifically less
// than any h_
if (rows_alloc < h_)
{
if (rows_alloc >= 0) // previously allocated
delete[] rows;
// find the first power-of-two not less than h_ (there's no
// real reason why it has to be a power of two, but this means
// that the allocated space grows gracefully).
for (rows_alloc = 1; rows_alloc < h_; rows_alloc *= 2)
;
rows = new RowPointer[rows_alloc];
if (verbosity_ > normal)
cerr << "PNGBitmap: allocated " << rows_alloc
<< "(" << h_ << ") row elements\n";
}
for (int r=0; r<h_; r++)
rows[r] = &bitmap_[r*w_];
png_write_image (png_ptr_, const_cast<Byte**>(rows));
png_write_end (png_ptr_,info_ptr_);
// Don't delete the write and info structs, since they're
// statically allocated, and usable by later (but not
// simultaneous) instances of this class.
fclose (pngfile);
}
void PNGBitmap::png_error_fn (png_structp png_ptr,
png_const_charp error_msg)
{
string err = "PNG error ";
err.append(error_msg);
throw BitmapError (err);
}
void PNGBitmap::png_warning_fn (png_structp png_ptr,
png_const_charp warning_msg)
{
if (verbosity_ > quiet)
cerr << "PNG warning: " << warning_msg;
}
#if GREYSCALE_BITMAP
// A row-transform function which inverts the greyscale. Bitmaps are
// sent to this class with zero being white and all-bits-on being
// black, which is opposite to what PNG wants. png_set_invert_mono
// doesn't do this, since it works for single-bit monochrome only, and
// not greyscale. This code patterned after the example in pngtest.c
static void png_invert_greyscale (png_structp png_ptr,
png_row_infop row_info,
png_bytep dp)
{
if (png_ptr == 0)
return;
if (row_info == 0 || dp == 0)
throw BitmapError ("Call of png_invert_greyscale with null pointers");
// sanity-check
if (row_info->color_type != 0 || row_info->channels != 1)
throw BitmapError ("Call of png_invert_greyscale with unknown colour model");
// contents of row_info:
// png_uint_32 width width of row
// png_uint_32 rowbytes number of bytes in row
// png_byte color_type color type of pixels
// png_byte bit_depth bit depth of samples
// png_byte channels number of channels (1-4)
// png_byte pixel_depth bits per pixel (depth*channels)
assert (row_info->bit_depth <= 8); // *dp is a byte
unsigned int maxval = (1<<row_info->bit_depth)-1;
/*
cout << "invert_greyscale: "
<< " bitdepth=" << static_cast<int>(row_info->bit_depth)
<< " => maxval=" << maxval
<< " channels=" << static_cast<int>(row_info->channels)
<< " color_type=" << static_cast<int>(row_info->color_type)
<< " width=" << row_info->width
<< " rowbytes=" << row_info->rowbytes
<< "\n";
*/
assert (row_info->width >= 0);
for (unsigned int n=0; n<row_info->width; n++, dp++)
*dp = maxval-*dp;
}
#endif