From 47d455dd55be855e4cc691c32f687f723d9247ee Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kfaxview/libkfaximage/kfaximage.cpp | 667 ++++++++++++++++++++++++++++++++++++ 1 file changed, 667 insertions(+) create mode 100644 kfaxview/libkfaximage/kfaximage.cpp (limited to 'kfaxview/libkfaximage/kfaximage.cpp') diff --git a/kfaxview/libkfaximage/kfaximage.cpp b/kfaxview/libkfaximage/kfaximage.cpp new file mode 100644 index 00000000..28744923 --- /dev/null +++ b/kfaxview/libkfaximage/kfaximage.cpp @@ -0,0 +1,667 @@ +/* + This file is part of KDE FAX image library + Copyright (c) 2005 Helge Deller + + based on Frank D. Cringle's viewfax package + Copyright (C) 1990, 1995 Frank D. Cringle. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License version 2 as published by the Free Software Foundation. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include + +#include + +#include +#include + +#include +#include +#include + +#include "faxexpand.h" +#include "kfaximage.h" + +static const char FAXMAGIC[] = "\000PC Research, Inc\000\000\000\000\000\000"; +static const char littleTIFF[] = "\x49\x49\x2a\x00"; +static const char bigTIFF[] = "\x4d\x4d\x00\x2a"; + +KFaxImage::KFaxImage( const QString &filename, QObject *parent, const char *name ) + : QObject(parent,name) +{ + KGlobal::locale()->insertCatalogue( QString::fromLatin1("libkfaximage") ); + loadImage(filename); +} + +KFaxImage::~KFaxImage() +{ } + +bool KFaxImage::loadImage( const QString &filename ) +{ + reset(); + + m_filename = filename; + m_errorString = QString::null; + + if (m_filename.isEmpty()) + return false; + + int ok = notetiff(); + if (!ok) { + reset(); + } + return ok == 1; +} + +void KFaxImage::reset() +{ + fax_init_tables(); + m_pagenodes.setAutoDelete(true); + m_pagenodes.clear(); + // do not reset m_errorString and m_filename, since + // they may be needed by calling application +} + +QImage KFaxImage::page( unsigned int pageNr ) +{ + if (pageNr >= numPages()) { + kdDebug() << "KFaxImage::page() called with invalid page number\n"; + return QImage(); + } + pagenode *pn = m_pagenodes.at(pageNr); + GetImage(pn); + return pn->image; +} + +QPoint KFaxImage::page_dpi( unsigned int pageNr ) +{ + if (pageNr >= numPages()) { + kdDebug() << "KFaxImage::page_dpi() called with invalid page number\n"; + return QPoint(0,0); + } + pagenode *pn = m_pagenodes.at(pageNr); + GetImage(pn); + return pn->dpi; +} + +QSize KFaxImage::page_size( unsigned int pageNr ) +{ + if (pageNr >= numPages()) { + kdDebug() << "KFaxImage::page_size() called with invalid page number\n"; + return QSize(0,0); + } + pagenode *pn = m_pagenodes.at(pageNr); + GetImage(pn); + return pn->size; +} + + +pagenode *KFaxImage::AppendImageNode(int type) +{ + pagenode *pn = new pagenode(); + if (pn) { + pn->type = type; + pn->expander = g31expand; + pn->strips = NULL; + pn->size = QSize(1728,2339); + pn->vres = -1; + pn->dpi = KFAX_DPI_FINE; + m_pagenodes.append(pn); + } + return pn; +} + +bool KFaxImage::NewImage(pagenode *pn, int w, int h) +{ + pn->image = QImage( w, h, 1, 2, QImage::systemByteOrder() ); + pn->image.setColor(0, qRgb(255,255,255)); + pn->image.setColor(1, qRgb(0,0,0)); + pn->data = (Q_UINT16*) pn->image.bits(); + pn->bytes_per_line = pn->image.bytesPerLine(); + pn->dpi = KFAX_DPI_FINE; + + return !pn->image.isNull(); +} + +void KFaxImage::FreeImage(pagenode *pn) +{ + pn->image = QImage(); + pn->data = NULL; + pn->bytes_per_line = 0; +} + +void KFaxImage::kfaxerror(const QString& error) +{ + m_errorString = error; + kdError() << "kfaxerror: " << error << endl; +} + + +/* Enter an argument in the linked list of pages */ +pagenode * +KFaxImage::notefile(int type) +{ + pagenode *newnode = new pagenode(); + newnode->type = type; + newnode->size = QSize(1728,0); + return newnode; +} + +static t32bits +get4(unsigned char *p, QImage::Endian endian) +{ + return (endian == QImage::BigEndian) + ? (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3] : + p[0]|(p[1]<<8)|(p[2]<<16)|(p[3]<<24); +} + +static int +get2(unsigned char *p, QImage::Endian endian) +{ + return (endian == QImage::BigEndian) ? (p[0]<<8)|p[1] : p[0]|(p[1]<<8); +} + +/* generate pagenodes for the images in a tiff file */ +int +KFaxImage::notetiff() +{ +#define SC(x) (char *)(x) + unsigned char header[8]; + QImage::Endian endian; + t32bits IFDoff; + pagenode *pn = NULL; + QString str; + + QFile file(filename()); + if (!file.open(IO_ReadOnly)) { + kfaxerror(i18n("Unable to open file for reading.")); + return 0; + } + + if (file.readBlock(SC(header), 8) != 8) { + kfaxerror(i18n("Unable to read file header (file too short).")); + return 0; + } + if (memcmp(header, &littleTIFF, 4) == 0) + endian = QImage::LittleEndian; + else if (memcmp(header, &bigTIFF, 4) == 0) + endian = QImage::BigEndian; + else { + maybe_RAW_FAX: + kfaxerror(i18n("This is not a TIFF FAX file.")); + // AppendImageNode(FAX_RAW); + return 0; + } + IFDoff = get4(header+4, endian); + if (IFDoff & 1) { + goto maybe_RAW_FAX; + } + do { /* for each page */ + unsigned char buf[8]; + unsigned char *dir = NULL , *dp = NULL; + int ndirent; + pixnum iwidth = 1728; + pixnum iheight = 2339; + int inverse = false; + int lsbfirst = 0; + int t4opt = 0, comp = 0; + int orient = TURN_NONE; + int yres = 196; /* 98.0 */ + struct strip *strips = NULL; + unsigned int rowsperstrip = 0; + t32bits nstrips = 1; + + if (!file.at(IFDoff)) { + realbad: + kfaxerror( i18n("Invalid or incomplete TIFF file.") ); + bad: + if (strips) + free(strips); + if (dir) + free(dir); + file.close(); + return 1; + } + if (file.readBlock(SC(buf), 2) != 2) + goto realbad; + ndirent = get2(buf, endian); + int len = 12*ndirent+4; + dir = (unsigned char *) malloc(len); + if (file.readBlock(SC(dir), len) != len) + goto realbad; + for (dp = dir; ndirent; ndirent--, dp += 12) { + /* for each directory entry */ + int tag, ftype; + t32bits count, value = 0; + tag = get2(dp, endian); + ftype = get2(dp+2, endian); + count = get4(dp+4, endian); + switch(ftype) { /* value is offset to list if count*size > 4 */ + case 3: /* short */ + value = get2(dp+8, endian); + break; + case 4: /* long */ + value = get4(dp+8, endian); + break; + case 5: /* offset to rational */ + value = get4(dp+8, endian); + break; + } + switch(tag) { + case 256: /* ImageWidth */ + iwidth = value; + break; + case 257: /* ImageLength */ + iheight = value; + break; + case 259: /* Compression */ + comp = value; + break; + case 262: /* PhotometricInterpretation */ + inverse ^= (value == 1); + break; + case 266: /* FillOrder */ + lsbfirst = (value == 2); + break; + case 273: /* StripOffsets */ + nstrips = count; + strips = (struct strip *) malloc(count * sizeof *strips); + if (count == 1 || (count == 2 && ftype == 3)) { + strips[0].offset = value; + if (count == 2) + strips[1].offset = get2(dp+10, endian); + break; + } + if (!file.at(value)) + goto realbad; + for (count = 0; count < nstrips; count++) { + if (file.readBlock(SC(buf), (ftype == 3) ? 2 : 4) <= 0) + goto realbad; + strips[count].offset = (ftype == 3) ? + get2(buf, endian) : get4(buf, endian); + } + break; + case 274: /* Orientation */ + switch(value) { + default: /* row0 at top, col0 at left */ + orient = 0; + break; + case 2: /* row0 at top, col0 at right */ + orient = TURN_M; + break; + case 3: /* row0 at bottom, col0 at right */ + orient = TURN_U; + break; + case 4: /* row0 at bottom, col0 at left */ + orient = TURN_U|TURN_M; + break; + case 5: /* row0 at left, col0 at top */ + orient = TURN_M|TURN_L; + break; + case 6: /* row0 at right, col0 at top */ + orient = TURN_U|TURN_L; + break; + case 7: /* row0 at right, col0 at bottom */ + orient = TURN_U|TURN_M|TURN_L; + break; + case 8: /* row0 at left, col0 at bottom */ + orient = TURN_L; + break; + } + break; + case 278: /* RowsPerStrip */ + rowsperstrip = value; + break; + case 279: /* StripByteCounts */ + if (count != nstrips) { + str = i18n("In file %1\nStripsPerImage tag 273=%2,tag279=%3\n") + .arg(filename()).arg(nstrips).arg(count); + kfaxerror(str); + goto realbad; + } + if (count == 1 || (count == 2 && ftype == 3)) { + strips[0].size = value; + if (count == 2) + strips[1].size = get2(dp+10, endian); + break; + } + if (!file.at(value)) + goto realbad; + for (count = 0; count < nstrips; count++) { + if (file.readBlock(SC(buf), (ftype == 3) ? 2 : 4) <= 0) + goto realbad; + strips[count].size = (ftype == 3) ? + get2(buf, endian) : get4(buf, endian); + } + break; + case 283: /* YResolution */ + if (!file.at(value) || + file.readBlock(SC(buf), 8) != 8) + goto realbad; + yres = get4(buf, endian) / get4(buf+4, endian); + break; + case 292: /* T4Options */ + t4opt = value; + break; + case 293: /* T6Options */ + /* later */ + break; + case 296: /* ResolutionUnit */ + if (value == 3) + yres = (yres * 254) / 100; /* *2.54 */ + break; + } + } + IFDoff = get4(dp, endian); + free(dir); + dir = NULL; + if (comp == 5) { + // compression type 5 is LZW compression // XXX + kfaxerror(i18n("Due to patent reasons LZW (Lempel-Ziv & Welch) " + "compressed Fax files cannot be loaded yet.\n")); + goto bad; + } + if (comp < 2 || comp > 4) { + kfaxerror(i18n("This version can only handle Fax files\n")); + goto bad; + } + pn = AppendImageNode(FAX_TIFF); + pn->nstrips = nstrips; + pn->rowsperstrip = nstrips > 1 ? rowsperstrip : iheight; + pn->strips = strips; + pn->size = QSize(iwidth,iheight); + pn->inverse = inverse; + pn->lsbfirst = lsbfirst; + pn->orient = orient; + pn->dpi.setY(yres); + pn->vres = (yres > 150) ? 1:0; /* arbitrary threshold for fine resolution */ + if (comp == 2) + pn->expander = MHexpand; + else if (comp == 3) + pn->expander = (t4opt & 1) ? g32expand : g31expand; + else + pn->expander = g4expand; + } while (IFDoff); + file.close(); + return 1; +#undef UC +} + +/* report error and remove bad file from the list */ +void +KFaxImage::badfile(pagenode *pn) +{ + kfaxerror(i18n("%1: Bad Fax File").arg(filename())); + FreeImage(pn); +} + +/* rearrange input bits into t16bits lsb-first chunks */ +static void +normalize(pagenode *pn, int revbits, int swapbytes, size_t length) +{ + t32bits *p = (t32bits *) pn->data; + + kdDebug() << "normalize = " << ((revbits<<1)|swapbytes) << endl; + switch ((revbits<<1)|swapbytes) { + case 0: + break; + case 1: + for ( ; length; length -= 4) { + t32bits t = *p; + *p++ = ((t & 0xff00ff00) >> 8) | ((t & 0x00ff00ff) << 8); + } + break; + case 2: + for ( ; length; length -= 4) { + t32bits t = *p; + t = ((t & 0xf0f0f0f0) >> 4) | ((t & 0x0f0f0f0f) << 4); + t = ((t & 0xcccccccc) >> 2) | ((t & 0x33333333) << 2); + *p++ = ((t & 0xaaaaaaaa) >> 1) | ((t & 0x55555555) << 1); + } + break; + case 3: + for ( ; length; length -= 4) { + t32bits t = *p; + t = ((t & 0xff00ff00) >> 8) | ((t & 0x00ff00ff) << 8); + t = ((t & 0xf0f0f0f0) >> 4) | ((t & 0x0f0f0f0f) << 4); + t = ((t & 0xcccccccc) >> 2) | ((t & 0x33333333) << 2); + *p++ = ((t & 0xaaaaaaaa) >> 1) | ((t & 0x55555555) << 1); + } + } +} + + +/* get compressed data into memory */ +unsigned char * +KFaxImage::getstrip(pagenode *pn, int strip) +{ + size_t offset, roundup; + unsigned char *Data; + + union { t16bits s; unsigned char b[2]; } so; +#define ShortOrder so.b[1] + so.s = 1; /* XXX */ + + QFile file(filename()); + if (!file.open(IO_ReadOnly)) { + badfile(pn); + return NULL; + } + + if (pn->strips == NULL) { + offset = 0; + pn->length = file.size(); + } + else if (strip < pn->nstrips) { + offset = pn->strips[strip].offset; + pn->length = pn->strips[strip].size; + } + else { + kfaxerror( i18n("Trying to expand too many strips.") ); + return NULL; + } + + /* round size to full boundary plus t32bits */ + roundup = (pn->length + 7) & ~3; + + Data = (unsigned char *) malloc(roundup); + /* clear the last 2 t32bits, to force the expander to terminate + even if the file ends in the middle of a fax line */ + *((t32bits *) Data + roundup/4 - 2) = 0; + *((t32bits *) Data + roundup/4 - 1) = 0; + + /* we expect to get it in one gulp... */ + if (!file.at(offset) || + (size_t) file.readBlock((char *)Data, pn->length) != pn->length) { + badfile(pn); + free(Data); + return NULL; + } + file.close(); + + pn->data = (t16bits *) Data; + if (pn->strips == NULL && memcmp(Data, FAXMAGIC, sizeof(FAXMAGIC)-1) == 0) { + /* handle ghostscript / PC Research fax file */ + if (Data[24] != 1 || Data[25] != 0){ + kfaxerror( i18n("Only the first page of the PC Research multipage file will be shown.") ); + } + pn->length -= 64; + pn->vres = Data[29]; + pn->data += 32; + roundup -= 64; + } + + normalize(pn, !pn->lsbfirst, ShortOrder, roundup); + if (pn->size.height() == 0) + pn->size.setHeight( G3count(pn, pn->expander == g32expand) ); + if (pn->size.height() == 0) { + + kfaxerror( i18n("No fax found in file.") ); + badfile(pn); + free(Data); + return NULL; + } + if (pn->strips == NULL) + pn->rowsperstrip = pn->size.height(); + return Data; +} + + +static void +drawline(pixnum *run, int LineNum, pagenode *pn) +{ + t32bits *p, *p1; /* p - current line, p1 - low-res duplicate */ + pixnum *r; /* pointer to run-lengths */ + t32bits pix; /* current pixel value */ + t32bits acc; /* pixel accumulator */ + int nacc; /* number of valid bits in acc */ + int tot; /* total pixels in line */ + int n; + + LineNum += pn->stripnum * pn->rowsperstrip; + if (LineNum >= pn->size.height()) { + if (LineNum == pn->size.height()) + kdError() << "Height exceeded\n"; + return; + } + + p = (t32bits *) pn->image.scanLine(LineNum*(2-pn->vres)); + p1 =(t32bits *)( pn->vres ? 0 : pn->image.scanLine(1+LineNum*(2-pn->vres))); + r = run; + acc = 0; + nacc = 0; + pix = pn->inverse ? ~0 : 0; + tot = 0; + while (tot < pn->size.width()) { + n = *r++; + tot += n; + /* Watch out for buffer overruns, e.g. when n == 65535. */ + if (tot > pn->size.width()) + break; + if (pix) + acc |= (~(t32bits)0 >> nacc); + else if (nacc) + acc &= (~(t32bits)0 << (32 - nacc)); + else + acc = 0; + if (nacc + n < 32) { + nacc += n; + pix = ~pix; + continue; + } + *p++ = acc; + if (p1) + *p1++ = acc; + n -= 32 - nacc; + while (n >= 32) { + n -= 32; + *p++ = pix; + if (p1) + *p1++ = pix; + } + acc = pix; + nacc = n; + pix = ~pix; + } + if (nacc) { + *p++ = acc; + if (p1) + *p1++ = acc; + } +} + +int +KFaxImage::GetPartImage(pagenode *pn, int n) +{ + unsigned char *Data = getstrip(pn, n); + if (Data == 0) + return 3; + pn->stripnum = n; + (*pn->expander)(pn, drawline); + free(Data); + return 1; +} + +int +KFaxImage::GetImage(pagenode *pn) +{ + if (!pn->image.isNull()) + return 1; + + int i; + if (pn->strips == 0) { + + kdDebug() << "Loading RAW fax file " << m_filename << " size=" << pn->size << endl; + + /* raw file; maybe we don't have the height yet */ + unsigned char *Data = getstrip(pn, 0); + if (Data == 0){ + return 0; + } + if (!NewImage(pn, pn->size.width(), (pn->vres ? 1:2) * pn->size.height())) + return 0; + + (*pn->expander)(pn, drawline); + } + else { + /* multi-strip tiff */ + kdDebug() << "Loading MULTI STRIP TIFF fax file " << m_filename << endl; + + if (!NewImage(pn, pn->size.width(), (pn->vres ? 1:2) * pn->size.height())) + return 0; + pn->stripnum = 0; + kdDebug() << "has " << pn->nstrips << " strips.\n"; + for (i = 0; i < pn->nstrips; i++){ + + int k = GetPartImage(pn, i); + if ( k == 3 ){ + FreeImage(pn); + kfaxerror( i18n("Fax G3 format not yet supported.") ); + return k; + } + + } + } + + // byte-swapping the image on little endian machines +#if defined(Q_BYTE_ORDER) && (Q_BYTE_ORDER == Q_LITTLE_ENDIAN) + for (int y=pn->image.height()-1; y>=0; --y) { + Q_UINT32 *source = (Q_UINT32 *) pn->image.scanLine(y); + Q_UINT32 *dest = source; + for (int x=(pn->bytes_per_line/4)-1; x>=0; --x) { + Q_UINT32 dv = 0, sv = *source; + for (int bit=32; bit>0; --bit) { + dv <<= 1; + dv |= sv&1; + sv >>= 1; + } + *dest = dv; + ++dest; + ++source; + } + } +#endif + + kdDebug() << filename() + << "\n\tsize = " << pn->size + << "\n\tDPI = " << pn->dpi + << "\n\tresolution = " << (pn->vres ? "fine" : "normal") + << endl; + + return 1; +} + + +#include "kfaximage.moc" -- cgit v1.2.1