You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqt3/src/kernel/qpngio.cpp

1257 lines
31 KiB

/****************************************************************************
**
** Implementation of PNG TQImage IOHandler
**
** Created : 970521
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the kernel module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "qpngio.h"
#ifndef QT_NO_IMAGEIO_PNG
#include "qasyncimageio.h"
#include "qiodevice.h"
#include <png.h>
#ifdef Q_OS_TEMP
#define CALLBACK_CALL_TYPE __cdecl
#else
#define CALLBACK_CALL_TYPE
#endif
/*
All PNG files load to the minimal TQImage equivalent.
All TQImage formats output to reasonably efficient PNG equivalents.
Never to grayscale.
*/
#if defined(Q_C_CALLBACKS)
extern "C" {
#endif
static
void CALLBACK_CALL_TYPE iod_read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
{
TQImageIO* iio = (TQImageIO*)png_get_io_ptr(png_ptr);
TQIODevice* in = iio->ioDevice();
while (length) {
int nr = in->readBlock((char*)data, length);
if (nr <= 0) {
png_error(png_ptr, "Read Error");
return;
}
length -= nr;
}
}
static
void CALLBACK_CALL_TYPE qpiw_write_fn( png_structp png_ptr, png_bytep data, png_size_t length )
{
TQPNGImageWriter* qpiw = (TQPNGImageWriter*)png_get_io_ptr( png_ptr );
TQIODevice* out = qpiw->device();
uint nr = out->writeBlock( (char*)data, length );
if ( nr != length ) {
png_error( png_ptr, "Write Error" );
return;
}
}
static
void CALLBACK_CALL_TYPE qpiw_flush_fn( png_structp png_ptr )
{
TQPNGImageWriter* qpiw = (TQPNGImageWriter*)png_get_io_ptr( png_ptr );
TQIODevice* out = qpiw->device();
out->flush();
}
#if defined(Q_C_CALLBACKS)
}
#endif
static
void setup_qt( TQImage& image, png_structp png_ptr, png_infop info_ptr, float screen_gamma=0.0 )
{
if ( screen_gamma != 0.0 && png_get_valid(png_ptr, info_ptr, PNG_INFO_gAMA) ) {
double file_gamma;
png_get_gAMA(png_ptr, info_ptr, &file_gamma);
png_set_gamma( png_ptr, screen_gamma, file_gamma );
}
png_uint_32 width;
png_uint_32 height;
int bit_depth;
int color_type;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
0, 0, 0);
if ( color_type == PNG_COLOR_TYPE_GRAY ) {
// Black & White or 8-bit grayscale
if ( bit_depth == 1 && info_ptr->channels == 1 ) {
png_set_invert_mono( png_ptr );
png_read_update_info( png_ptr, info_ptr );
if (!image.create( width, height, 1, 2, TQImage::BigEndian ))
return;
image.setColor( 1, qRgb(0,0,0) );
image.setColor( 0, qRgb(255,255,255) );
} else if (bit_depth == 16 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_set_expand(png_ptr);
png_set_strip_16(png_ptr);
png_set_gray_to_rgb(png_ptr);
if (!image.create(width, height, 32))
return;
image.setAlphaBuffer(TRUE);
if (TQImage::systemByteOrder() == TQImage::BigEndian)
png_set_swap_alpha(png_ptr);
png_read_update_info(png_ptr, info_ptr);
} else {
if ( bit_depth == 16 )
png_set_strip_16(png_ptr);
else if ( bit_depth < 8 )
png_set_packing(png_ptr);
int ncols = bit_depth < 8 ? 1 << bit_depth : 256;
png_read_update_info(png_ptr, info_ptr);
if (!image.create(width, height, 8, ncols))
return;
for (int i=0; i<ncols; i++) {
int c = i*255/(ncols-1);
image.setColor( i, qRgba(c,c,c,0xff) );
}
if ( png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) ) {
#if PNG_LIBPNG_VER_MAJOR>1 || ( PNG_LIBPNG_VER_MAJOR==1 && PNG_LIBPNG_VER_MINOR>=4 )
const int g = info_ptr->trans_color.gray;
#else
const int g = info_ptr->trans_values.gray;
#endif
if (g < ncols) {
image.setAlphaBuffer(TRUE);
image.setColor(g, image.color(g) & RGB_MASK);
}
}
}
} else if ( color_type == PNG_COLOR_TYPE_PALETTE
&& png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE)
&& info_ptr->num_palette <= 256 )
{
// 1-bit and 8-bit color
if ( bit_depth != 1 )
png_set_packing( png_ptr );
png_read_update_info( png_ptr, info_ptr );
png_get_IHDR(png_ptr, info_ptr,
&width, &height, &bit_depth, &color_type, 0, 0, 0);
if (!image.create(width, height, bit_depth, info_ptr->num_palette,
TQImage::BigEndian))
return;
int i = 0;
if ( png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) ) {
image.setAlphaBuffer( TRUE );
while ( i < info_ptr->num_trans ) {
image.setColor(i, qRgba(
info_ptr->palette[i].red,
info_ptr->palette[i].green,
info_ptr->palette[i].blue,
#if PNG_LIBPNG_VER_MAJOR>1 || ( PNG_LIBPNG_VER_MAJOR==1 && PNG_LIBPNG_VER_MINOR>=4 )
info_ptr->trans_alpha[i]
#else
info_ptr->trans[i]
#endif
)
);
i++;
}
}
while ( i < info_ptr->num_palette ) {
image.setColor(i, qRgba(
info_ptr->palette[i].red,
info_ptr->palette[i].green,
info_ptr->palette[i].blue,
0xff
)
);
i++;
}
} else {
// 32-bit
if ( bit_depth == 16 )
png_set_strip_16(png_ptr);
png_set_expand(png_ptr);
if ( color_type == PNG_COLOR_TYPE_GRAY_ALPHA )
png_set_gray_to_rgb(png_ptr);
if (!image.create(width, height, 32))
return;
// Only add filler if no alpha, or we can get 5 channel data.
if (!(color_type & PNG_COLOR_MASK_ALPHA)
&& !png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_set_filler(png_ptr, 0xff,
TQImage::systemByteOrder() == TQImage::BigEndian ?
PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
// We want 4 bytes, but it isn't an alpha channel
} else {
image.setAlphaBuffer(TRUE);
}
if ( TQImage::systemByteOrder() == TQImage::BigEndian ) {
png_set_swap_alpha(png_ptr);
}
png_read_update_info(png_ptr, info_ptr);
}
// TQt==ARGB==Big(ARGB)==Little(BGRA)
if ( TQImage::systemByteOrder() == TQImage::LittleEndian ) {
png_set_bgr(png_ptr);
}
}
#if defined(Q_C_CALLBACKS)
extern "C" {
#endif
static void CALLBACK_CALL_TYPE qt_png_warning(png_structp /*png_ptr*/, png_const_charp message)
{
qWarning("libpng warning: %s", message);
}
#if defined(Q_C_CALLBACKS)
}
#endif
static
void read_png_image(TQImageIO* iio)
{
png_structp png_ptr;
png_infop info_ptr;
png_infop end_info;
png_bytep* row_pointers;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
iio->setStatus(-1);
return;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, 0, 0);
iio->setStatus(-2);
return;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
iio->setStatus(-3);
return;
}
if (setjmp(png_ptr->jmpbuf)) {
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
iio->setStatus(-4);
return;
}
png_set_read_fn(png_ptr, (void*)iio, iod_read_fn);
png_read_info(png_ptr, info_ptr);
TQImage image;
setup_qt(image, png_ptr, info_ptr, iio->gamma());
if (image.isNull()) {
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
iio->setStatus(-5);
return;
}
png_uint_32 width;
png_uint_32 height;
int bit_depth;
int color_type;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
0, 0, 0);
uchar** jt = image.jumpTable();
row_pointers=new png_bytep[height];
for (uint y=0; y<height; y++) {
row_pointers[y]=jt[y];
}
png_read_image(png_ptr, row_pointers);
#if 0 // libpng takes care of this.
png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)
if (image.depth()==32 && png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
TQRgb trans = 0xFF000000 | qRgb(
#if PNG_LIBPNG_VER_MAJOR>1 || ( PNG_LIBPNG_VER_MAJOR==1 && PNG_LIBPNG_VER_MINOR>=4 )
(info_ptr->trans_color.red << 8 >> bit_depth)&0xff,
(info_ptr->trans_color.green << 8 >> bit_depth)&0xff,
(info_ptr->trans_color.blue << 8 >> bit_depth)&0xff);
#else
(info_ptr->trans_values.red << 8 >> bit_depth)&0xff,
(info_ptr->trans_values.green << 8 >> bit_depth)&0xff,
(info_ptr->trans_values.blue << 8 >> bit_depth)&0xff);
#endif
for (uint y=0; y<height; y++) {
for (uint x=0; x<info_ptr->width; x++) {
if (((uint**)jt)[y][x] == trans) {
((uint**)jt)[y][x] &= 0x00FFFFFF;
} else {
}
}
}
}
#endif
image.setDotsPerMeterX(png_get_x_pixels_per_meter(png_ptr,info_ptr));
image.setDotsPerMeterY(png_get_y_pixels_per_meter(png_ptr,info_ptr));
#ifndef QT_NO_IMAGE_TEXT
png_textp text_ptr;
int num_text=0;
png_get_text(png_ptr,info_ptr,&text_ptr,&num_text);
while (num_text--) {
image.setText(text_ptr->key,0,text_ptr->text);
text_ptr++;
}
#endif
delete [] row_pointers;
if ( image.hasAlphaBuffer() ) {
// Many PNG files lie (eg. from PhotoShop). Fortunately this loop will
// usually be tquick to find those that tell the truth.
TQRgb* c;
int n;
if (image.depth()==32) {
c = (TQRgb*)image.bits();
n = image.bytesPerLine() * image.height() / 4;
} else {
c = image.colorTable();
n = image.numColors();
}
while ( n-- && qAlpha(*c++)==0xff )
;
if ( n<0 ) // LIAR!
image.setAlphaBuffer(FALSE);
}
iio->setImage(image);
png_read_end(png_ptr, end_info);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
iio->setStatus(0);
}
TQPNGImageWriter::TQPNGImageWriter(TQIODevice* iod) :
dev(iod),
frames_written(0),
disposal(Unspecified),
looping(-1),
ms_delay(-1),
gamma(0.0)
{
}
TQPNGImageWriter::~TQPNGImageWriter()
{
}
void TQPNGImageWriter::setDisposalMethod(DisposalMethod dm)
{
disposal = dm;
}
void TQPNGImageWriter::setLooping(int loops)
{
looping = loops;
}
void TQPNGImageWriter::setFrameDelay(int msecs)
{
ms_delay = msecs;
}
void TQPNGImageWriter::setGamma(float g)
{
gamma = g;
}
#ifndef QT_NO_IMAGE_TEXT
static void set_text(const TQImage& image, png_structp png_ptr, png_infop info_ptr, bool short_not_long)
{
TQValueList<TQImageTextKeyLang> keys = image.textList();
if ( keys.count() ) {
png_textp text_ptr = new png_text[keys.count()];
int i=0;
for (TQValueList<TQImageTextKeyLang>::Iterator it=keys.begin();
it != keys.end(); ++it)
{
TQString t = image.text(*it);
if ( (t.length() <= 200) == short_not_long ) {
if ( t.length() < 40 )
text_ptr[i].compression = PNG_TEXT_COMPRESSION_NONE;
else
text_ptr[i].compression = PNG_TEXT_COMPRESSION_zTXt;
text_ptr[i].key = (png_charp)(*it).key.data();
text_ptr[i].text = (png_charp)t.latin1();
//text_ptr[i].text = qstrdup(t.latin1());
i++;
}
}
png_set_text(png_ptr, info_ptr, text_ptr, i);
//for (int j=0; j<i; j++)
//free(text_ptr[i].text);
delete [] text_ptr;
}
}
#endif
bool TQPNGImageWriter::writeImage(const TQImage& image, int off_x, int off_y)
{
return writeImage(image, -1, off_x, off_y);
}
bool TQPNGImageWriter::writeImage(const TQImage& image, int quality_in, int off_x_in, int off_y_in)
{
TQPoint offset = image.offset();
int off_x = off_x_in + offset.x();
int off_y = off_y_in + offset.y();
png_structp png_ptr;
png_infop info_ptr;
png_bytep* row_pointers;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
if (!png_ptr) {
return FALSE;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, 0);
return FALSE;
}
if (setjmp(png_ptr->jmpbuf)) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return FALSE;
}
int quality = quality_in;
if (quality >= 0) {
if (quality > 9) {
#if defined(QT_CHECK_RANGE)
qWarning( "PNG: Quality %d out of range", quality );
#endif
quality = 9;
}
png_set_compression_level(png_ptr, quality);
}
if (gamma != 0.0) {
png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
}
png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
info_ptr->channels =
(image.depth() == 32)
? (image.hasAlphaBuffer() ? 4 : 3)
: 1;
png_set_IHDR(png_ptr, info_ptr, image.width(), image.height(),
image.depth() == 1 ? 1 : 8 /* per channel */,
image.depth() == 32
? image.hasAlphaBuffer()
? PNG_COLOR_TYPE_RGB_ALPHA
: PNG_COLOR_TYPE_RGB
: PNG_COLOR_TYPE_PALETTE, 0, 0, 0);
//png_set_sBIT(png_ptr, info_ptr, 8);
info_ptr->sig_bit.red = 8;
info_ptr->sig_bit.green = 8;
info_ptr->sig_bit.blue = 8;
if (image.depth() == 1 && image.bitOrder() == TQImage::LittleEndian)
png_set_packswap(png_ptr);
png_colorp palette = 0;
png_bytep copy_trans = 0;
if (image.numColors()) {
// Paletted
int num_palette = image.numColors();
palette = new png_color[num_palette];
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
int* trans = new int[num_palette];
int num_trans = 0;
for (int i=0; i<num_palette; i++) {
TQRgb rgb=image.color(i);
info_ptr->palette[i].red = qRed(rgb);
info_ptr->palette[i].green = qGreen(rgb);
info_ptr->palette[i].blue = qBlue(rgb);
if (image.hasAlphaBuffer()) {
trans[i] = rgb >> 24;
if (trans[i] < 255) {
num_trans = i+1;
}
}
}
if (num_trans) {
copy_trans = new png_byte[num_trans];
for (int i=0; i<num_trans; i++)
copy_trans[i] = trans[i];
png_set_tRNS(png_ptr, info_ptr, copy_trans, num_trans, 0);
}
delete [] trans;
}
if ( image.hasAlphaBuffer() ) {
info_ptr->sig_bit.alpha = 8;
}
// Swap ARGB to RGBA (normal PNG format) before saving on
// BigEndian machines
if ( TQImage::systemByteOrder() == TQImage::BigEndian ) {
png_set_swap_alpha(png_ptr);
}
// TQt==ARGB==Big(ARGB)==Little(BGRA)
if ( TQImage::systemByteOrder() == TQImage::LittleEndian ) {
png_set_bgr(png_ptr);
}
if (off_x || off_y) {
png_set_oFFs(png_ptr, info_ptr, off_x, off_y, PNG_OFFSET_PIXEL);
}
if ( frames_written > 0 )
png_set_sig_bytes(png_ptr, 8);
if ( image.dotsPerMeterX() > 0 || image.dotsPerMeterY() > 0 ) {
png_set_pHYs(png_ptr, info_ptr,
image.dotsPerMeterX(), image.dotsPerMeterY(),
PNG_RESOLUTION_METER);
}
#ifndef QT_NO_IMAGE_TEXT
// Write short texts early.
set_text(image,png_ptr,info_ptr,TRUE);
#endif
png_write_info(png_ptr, info_ptr);
#ifndef QT_NO_IMAGE_TEXT
// Write long texts later.
set_text(image,png_ptr,info_ptr,FALSE);
#endif
if ( image.depth() != 1 )
png_set_packing(png_ptr);
if ( image.depth() == 32 && !image.hasAlphaBuffer() )
png_set_filler(png_ptr, 0,
TQImage::systemByteOrder() == TQImage::BigEndian ?
PNG_FILLER_BEFORE : PNG_FILLER_AFTER);
if ( looping >= 0 && frames_written == 0 ) {
uchar data[13] = "NETSCAPE2.0";
// 0123456789aBC
data[0xB] = looping%0x100;
data[0xC] = looping/0x100;
png_write_chunk(png_ptr, (png_byte*)"gIFx", data, 13);
}
if ( ms_delay >= 0 || disposal!=Unspecified ) {
uchar data[4];
data[0] = disposal;
data[1] = 0;
data[2] = (ms_delay/10)/0x100; // hundredths
data[3] = (ms_delay/10)%0x100;
png_write_chunk(png_ptr, (png_byte*)"gIFg", data, 4);
}
png_uint_32 width;
png_uint_32 height;
int bit_depth;
int color_type;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
0, 0, 0);
uchar** jt = image.jumpTable();
row_pointers=new png_bytep[height];
uint y;
for (y=0; y<height; y++) {
row_pointers[y]=jt[y];
}
png_write_image(png_ptr, row_pointers);
delete [] row_pointers;
png_write_end(png_ptr, info_ptr);
frames_written++;
if ( palette )
delete [] palette;
if ( copy_trans )
delete [] copy_trans;
png_destroy_write_struct(&png_ptr, &info_ptr);
return TRUE;
}
static
void write_png_image(TQImageIO* iio)
{
TQPNGImageWriter writer(iio->ioDevice());
int quality = iio->quality();
if ( quality >= 0 ) {
quality = TQMIN( quality, 100 );
quality = (100-quality) * 9 / 91; // map [0,100] -> [9,0]
}
writer.setGamma(iio->gamma());
bool ok = writer.writeImage( iio->image(), quality );
iio->setStatus( ok ? 0 : -1 );
}
/*!
\class TQPNGImagePacker qpngio.h
\brief The TQPNGImagePacker class creates well-compressed PNG animations.
\ingroup images
\ingroup graphics
By using transparency, TQPNGImagePacker allows you to build a PNG
image from a sequence of TQImages.
Images are added using packImage().
*/
/*!
Creates an image packer that writes PNG data to IO device \a iod
using a \a storage_depth bit encoding (use 8 or 32, depending on
the desired quality and compression requirements).
If the image needs to be modified to fit in a lower-resolution
result (e.g. converting from 32-bit to 8-bit), use the \a
conversionflags to specify how you'd prefer this to happen.
\sa TQt::ImageConversionFlags
*/
TQPNGImagePacker::TQPNGImagePacker(TQIODevice* iod, int storage_depth,
int conversionflags) :
TQPNGImageWriter(iod),
depth(storage_depth),
convflags(conversionflags),
alignx(1)
{
}
/*!
Aligns pixel differences to \a x pixels. For example, using 8 can
improve playback on certain hardware. Normally the default of
1-pixel alignment (i.e. no alignment) gives better compression and
performance.
*/
void TQPNGImagePacker::setPixelAlignment(int x)
{
alignx = x;
}
/*!
Adds the image \a img to the PNG animation, analyzing the
differences between this and the previous image to improve
compression.
*/
bool TQPNGImagePacker::packImage(const TQImage& img)
{
TQImage image = img.convertDepth(32);
if ( previous.isNull() ) {
// First image
writeImage(image.convertDepth(depth,convflags));
} else {
bool done;
int minx, maxx, miny, maxy;
int w = image.width();
int h = image.height();
TQRgb** jt = (TQRgb**)image.jumpTable();
TQRgb** pjt = (TQRgb**)previous.jumpTable();
// Find left edge of change
done = FALSE;
for (minx = 0; minx < w && !done; minx++) {
for (int ty = 0; ty < h; ty++) {
if ( jt[ty][minx] != pjt[ty][minx] ) {
done = TRUE;
break;
}
}
}
minx--;
// Find right edge of change
done = FALSE;
for (maxx = w-1; maxx >= 0 && !done; maxx--) {
for (int ty = 0; ty < h; ty++) {
if ( jt[ty][maxx] != pjt[ty][maxx] ) {
done = TRUE;
break;
}
}
}
maxx++;
// Find top edge of change
done = FALSE;
for (miny = 0; miny < h && !done; miny++) {
for (int tx = 0; tx < w; tx++) {
if ( jt[miny][tx] != pjt[miny][tx] ) {
done = TRUE;
break;
}
}
}
miny--;
// Find right edge of change
done = FALSE;
for (maxy = h-1; maxy >= 0 && !done; maxy--) {
for (int tx = 0; tx < w; tx++) {
if ( jt[maxy][tx] != pjt[maxy][tx] ) {
done = TRUE;
break;
}
}
}
maxy++;
if ( minx > maxx ) minx=maxx=0;
if ( miny > maxy ) miny=maxy=0;
if ( alignx > 1 ) {
minx -= minx % alignx;
maxx = maxx - maxx % alignx + alignx - 1;
}
int dw = maxx-minx+1;
int dh = maxy-miny+1;
TQImage diff(dw, dh, 32);
diff.setAlphaBuffer(TRUE);
int x, y;
if ( alignx < 1 )
alignx = 1;
for (y = 0; y < dh; y++) {
TQRgb* li = (TQRgb*)image.scanLine(y+miny)+minx;
TQRgb* lp = (TQRgb*)previous.scanLine(y+miny)+minx;
TQRgb* ld = (TQRgb*)diff.scanLine(y);
if ( alignx ) {
for (x = 0; x < dw; x+=alignx) {
int i;
for (i=0; i<alignx; i++) {
if ( li[x+i] != lp[x+i] )
break;
}
if ( i == alignx ) {
// All the same
for (i=0; i<alignx; i++) {
ld[x+i] = qRgba(0,0,0,0);
}
} else {
// Some different
for (i=0; i<alignx; i++) {
ld[x+i] = 0xff000000 | li[x+i];
}
}
}
} else {
for (x = 0; x < dw; x++) {
if ( li[x] != lp[x] )
ld[x] = 0xff000000 | li[x];
else
ld[x] = qRgba(0,0,0,0);
}
}
}
diff = diff.convertDepth(depth,convflags);
if ( !writeImage(diff, minx, miny) )
return FALSE;
}
previous = image;
return TRUE;
}
#ifndef QT_NO_ASYNC_IMAGE_IO
class TQPNGFormat : public TQImageFormat {
public:
TQPNGFormat();
virtual ~TQPNGFormat();
int decode(TQImage& img, TQImageConsumer* consumer,
const uchar* buffer, int length);
void info(png_structp png_ptr, png_infop info);
void row(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass);
void end(png_structp png_ptr, png_infop info);
#ifdef PNG_USER_CHUNKS_SUPPORTED
int user_chunk(png_structp png_ptr,
png_bytep data, png_uint_32 length);
#endif
private:
// Animation-level information
enum { MovieStart, FrameStart, Inside, End } state;
int first_frame;
int base_offx;
int base_offy;
// Image-level information
png_structp png_ptr;
png_infop info_ptr;
// Temporary locals during single data-chunk processing
TQImageConsumer* consumer;
TQImage* image;
int unused_data;
};
class TQPNGFormatType : public TQImageFormatType
{
TQImageFormat* decoderFor(const uchar* buffer, int length);
const char* formatName() const;
};
/*
\class TQPNGFormat qpngio.h
\brief The TQPNGFormat class provides an incremental image decoder for PNG
image format.
\ingroup images
\ingroup graphics
This subclass of TQImageFormat decodes PNG format images,
including animated PNGs.
Animated PNG images are standard PNG images. The PNG standard
defines two extension chunks that are useful for animations:
\list
\i gIFg - GIF-like Graphic Control Extension.
This includes frame disposal, user input flag (we ignore this),
and inter-frame delay.
\i gIFx - GIF-like Application Extension.
This is multi-purpose, but we just use the Netscape extension
which specifies looping.
\endlist
The subimages usually contain a offset chunk (oFFs) but need not.
The first image defines the "screen" size. Any subsequent image that
doesn't fit is clipped.
*/
/* ###TODO: decide on this point. gIFg gives disposal types, so it can be done.
All images paste (\e not composite, just place all-channel copying)
over the previous image to produce a subsequent frame.
*/
/*
\class TQPNGFormatType qasyncimageio.h
\brief The TQPNGFormatType class provides an incremental image decoder
for PNG image format.
\ingroup images
\ingroup graphics
\ingroup io
This subclass of TQImageFormatType recognizes PNG format images, creating
a TQPNGFormat when required. An instance of this class is created
automatically before any other factories, so you should have no need for
such objects.
*/
TQImageFormat* TQPNGFormatType::decoderFor(
const uchar* buffer, int length)
{
if (length < 8) return 0;
if (buffer[0]==137
&& buffer[1]=='P'
&& buffer[2]=='N'
&& buffer[3]=='G'
&& buffer[4]==13
&& buffer[5]==10
&& buffer[6]==26
&& buffer[7]==10)
return new TQPNGFormat;
return 0;
}
const char* TQPNGFormatType::formatName() const
{
return "PNG";
}
#if defined(Q_C_CALLBACKS)
extern "C" {
#endif
static void
CALLBACK_CALL_TYPE info_callback(png_structp png_ptr, png_infop info)
{
TQPNGFormat* that = (TQPNGFormat*)png_get_progressive_ptr(png_ptr);
that->info(png_ptr,info);
}
static void
CALLBACK_CALL_TYPE row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass)
{
TQPNGFormat* that = (TQPNGFormat*)png_get_progressive_ptr(png_ptr);
that->row(png_ptr,new_row,row_num,pass);
}
static void
CALLBACK_CALL_TYPE end_callback(png_structp png_ptr, png_infop info)
{
TQPNGFormat* that = (TQPNGFormat*)png_get_progressive_ptr(png_ptr);
that->end(png_ptr,info);
}
#if 0
#ifdef PNG_USER_CHUNKS_SUPPORTED
static int
CALLBACK_CALL_TYPE user_chunk_callback(png_structp png_ptr,
png_unknown_chunkp chunk)
{
TQPNGFormat* that = (TQPNGFormat*)png_get_progressive_ptr(png_ptr);
return that->user_chunk(png_ptr,chunk->data,chunk->size);
}
#endif
#endif
#if defined(Q_C_CALLBACKS)
}
#endif
/*!
Constructs a TQPNGFormat object.
*/
TQPNGFormat::TQPNGFormat()
{
state = MovieStart;
first_frame = 1;
base_offx = 0;
base_offy = 0;
png_ptr = 0;
info_ptr = 0;
}
/*!
Destroys a TQPNGFormat object.
*/
TQPNGFormat::~TQPNGFormat()
{
if ( png_ptr )
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
}
/*!
This function decodes some data into image changes.
Returns the number of bytes consumed.
*/
int TQPNGFormat::decode(TQImage& img, TQImageConsumer* cons,
const uchar* buffer, int length)
{
consumer = cons;
image = &img;
if ( state != Inside ) {
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
if (!png_ptr) {
info_ptr = 0;
image = 0;
return -1;
}
png_set_error_fn(png_ptr, 0, 0, qt_png_warning);
png_set_compression_level(png_ptr, 9);
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
image = 0;
return -1;
}
if (setjmp((png_ptr)->jmpbuf)) {
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
image = 0;
return -1;
}
png_set_progressive_read_fn(png_ptr, (void *)this,
info_callback, row_callback, end_callback);
#ifdef PNG_USER_CHUNKS_SUPPORTED
// Can't do this yet. libpng has a crash bug with unknown (user) chunks.
// Warwick has sent them a patch.
// png_set_read_user_chunk_fn(png_ptr, 0, user_chunk_callback);
// png_set_keep_unknown_chunks(png_ptr, 2/*HANDLE_CHUNK_IF_SAFE*/, 0, 0);
#endif
if ( state != MovieStart && *buffer != 0211 ) {
// Good, no signature - the preferred way to concat PNG images.
// Skip them.
png_set_sig_bytes(png_ptr, 8);
}
state = Inside;
}
if ( !png_ptr ) return 0;
if (setjmp(png_ptr->jmpbuf)) {
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
image = 0;
state = MovieStart;
return -1;
}
unused_data = 0;
png_process_data(png_ptr, info_ptr, (png_bytep)buffer, length);
int l = length - unused_data;
// TODO: send incremental stuff to consumer (optional)
if ( state != Inside ) {
if ( png_ptr )
png_destroy_read_struct(&png_ptr, &info_ptr, 0);
}
image = 0;
return l;
}
void TQPNGFormat::info(png_structp png, png_infop)
{
png_set_interlace_handling(png);
setup_qt(*image, png, info_ptr);
}
void TQPNGFormat::row(png_structp png, png_bytep new_row,
png_uint_32 row_num, int)
{
uchar* old_row = image->scanLine(row_num);
png_progressive_combine_row(png, old_row, new_row);
}
void TQPNGFormat::end(png_structp png, png_infop info)
{
int offx = png_get_x_offset_pixels(png,info) - base_offx;
int offy = png_get_y_offset_pixels(png,info) - base_offy;
if ( first_frame ) {
base_offx = offx;
base_offy = offy;
first_frame = 0;
}
image->setOffset(TQPoint(offx,offy));
image->setDotsPerMeterX(png_get_x_pixels_per_meter(png,info));
image->setDotsPerMeterY(png_get_y_pixels_per_meter(png,info));
#ifndef QT_NO_IMAGE_TEXT
png_textp text_ptr;
int num_text=0;
png_get_text(png,info,&text_ptr,&num_text);
while (num_text--) {
image->setText(text_ptr->key,0,text_ptr->text);
text_ptr++;
}
#endif
TQRect r(0,0,image->width(),image->height());
consumer->frameDone(TQPoint(offx,offy),r);
consumer->end();
state = FrameStart;
unused_data = (int)png->buffer_size; // Since libpng doesn't tell us
}
#ifdef PNG_USER_CHUNKS_SUPPORTED
/*
#ifndef QT_NO_IMAGE_TEXT
static bool skip(png_uint_32& max, png_bytep& data)
{
while (*data) {
if ( !max ) return FALSE;
max--;
data++;
}
if ( !max ) return FALSE;
max--;
data++; // skip to after NUL
return TRUE;
}
#endif
*/
int TQPNGFormat::user_chunk(png_structp png,
png_bytep data, png_uint_32 length)
{
#if 0 // NOT SUPPORTED: experimental PNG animation.
// qDebug("Got %ld-byte %s chunk", length, png->chunk_name);
if ( 0==qstrcmp((char*)png->chunk_name, "gIFg")
&& length == 4 ) {
//TQPNGImageWriter::DisposalMethod disposal =
// (TQPNGImageWriter::DisposalMethod)data[0];
// ### TODO: use the disposal method
int ms_delay = ((data[2] << 8) | data[3])*10;
consumer->setFramePeriod(ms_delay);
return 1;
} else if ( 0==qstrcmp((char*)png->chunk_name, "gIFx")
&& length == 13 ) {
if ( qstrncmp((char*)data,"NETSCAPE2.0",11)==0 ) {
int looping = (data[0xC]<<8)|data[0xB];
consumer->setLooping(looping);
return 1;
}
}
#else
Q_UNUSED( png )
Q_UNUSED( data )
Q_UNUSED( length )
#endif
#ifndef QT_NO_IMAGE_TEXT
/*
libpng now supports this chunk.
if ( 0==qstrcmp((char*)png->chunk_name, "iTXt") && length>=6 ) {
const char* keyword = (const char*)data;
if ( !skip(length,data) ) return 0;
if ( length >= 4 ) {
char compression_flag = *data++;
char compression_method = *data++;
if ( compression_flag == compression_method ) {
// fool the compiler into thinking they're used
}
const char* lang = (const char*)data;
if ( !skip(length,data) ) return 0;
// const char* keyword_utf8 = (const char*)data;
if ( !skip(length,data) ) return 0;
const char* text_utf8 = (const char*)data;
if ( !skip(length,data) ) return 0;
TQString text = TQString::fromUtf8(text_utf8);
image->setText(keyword,lang[0] ? lang : 0,text);
return 1;
}
}
*/
#endif
return 0;
}
#endif
static TQPNGFormatType* globalPngFormatTypeObject = 0;
#endif // QT_NO_ASYNC_IMAGE_IO
static bool done = FALSE;
void qCleanupPngIO()
{
#ifndef QT_NO_ASYNC_IMAGE_IO
if ( globalPngFormatTypeObject ) {
delete globalPngFormatTypeObject;
globalPngFormatTypeObject = 0;
}
#endif
done = FALSE;
}
void qInitPngIO()
{
if ( !done ) {
done = TRUE;
TQImageIO::defineIOHandler( "PNG", "^.PNG\r", 0, read_png_image,
write_png_image);
#ifndef QT_NO_ASYNC_IMAGE_IO
globalPngFormatTypeObject = new TQPNGFormatType;
#endif
qAddPostRoutine( qCleanupPngIO );
}
}
void qt_zlib_compression_hack()
{
compress(0,0,0,0);
uncompress(0,0,0,0);
}
#endif // QT_NO_IMAGEIO_PNG