okular/generators/fax/faxdocument.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Tobias Koenig <tokoe@kde.org>                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#include "faxdocument.h"

#include <stdlib.h>

#include <QFile>

#include "faxexpand.h"

static const char FAXMAGIC[] = "\000PC Research, Inc\000\000\000\000\000\000";

#define FAX_DPI_FINE QPoint(203, 196)

/* rearrange input bits into t16bits lsb-first chunks */
static void normalize(pagenode *pn, int revbits, int swapbytes, size_t length)
{
    t32bits *p = reinterpret_cast<t32bits *>(pn->data);

    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);
        }
    }
}

static bool new_image(pagenode *pn, int width, int height)
{
    pn->image = QImage(width, height, QImage::Format_MonoLSB);
    pn->image.setColor(0, qRgb(255, 255, 255));
    pn->image.setColor(1, qRgb(0, 0, 0));
    pn->bytes_per_line = pn->image.bytesPerLine();
    pn->dpi = FAX_DPI_FINE;
    pn->imageData = new uchar[width * height];

    return !pn->image.isNull();
}

/* get compressed data into memory */
static unsigned char *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(pn->filename);
    if (!file.open(QIODevice::ReadOnly))
        return nullptr;

    if (pn->strips == nullptr) {
        offset = 0;
        pn->length = file.size();
    } else if (strip < pn->nstrips) {
        offset = pn->strips[strip].offset;
        pn->length = pn->strips[strip].size;
    } else
        return nullptr;

    /* round size to full boundary plus t32bits */
    roundup = (pn->length + 7) & ~3;

    data = new uchar[roundup];
    /* clear the last 2 t32bits, to force the expander to terminate
       even if the file ends in the middle of a fax line  */
    *(reinterpret_cast<t32bits *>(data + roundup / 4 - 2)) = 0;
    *(reinterpret_cast<t32bits *>(data + roundup / 4 - 1)) = 0;

    /* we expect to get it in one gulp... */
    if (!file.seek(offset) || (size_t)file.read((char *)data, pn->length) != pn->length) {
        delete[] data;
        return nullptr;
    }
    file.close();

    pn->data = reinterpret_cast<t16bits *>(data);

    if (pn->strips == nullptr && memcmp(data, FAXMAGIC, sizeof(FAXMAGIC) - 1) == 0) {
        /* handle ghostscript / PC Research fax file */
        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) {
        delete[] data;
        pn->data = nullptr;
        return nullptr;
    }

    if (pn->strips == nullptr)
        pn->rowsperstrip = pn->size.height();

    pn->dataOrig = reinterpret_cast<t16bits *>(data);

    return data;
}

static void draw_line(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())
        return;

    p = reinterpret_cast<t32bits *>(pn->imageData + lineNum * (2 - pn->vres) * pn->bytes_per_line);
    p1 = reinterpret_cast<t32bits *>(pn->vres ? nullptr : p + pn->bytes_per_line / sizeof(*p));

    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;
    }
}

static bool get_image(pagenode *pn)
{
    unsigned char *data = getstrip(pn, 0);
    if (!data)
        return false;

    if (!new_image(pn, pn->size.width(), (pn->vres ? 1 : 2) * pn->size.height()))
        return false;

    (*pn->expander)(pn, draw_line);

    return true;
}

class FaxDocument::Private
{
public:
    Private(FaxDocument *parent)
        : mParent(parent)
    {
        mPageNode.size = QSize(1728, 0);
    }

    FaxDocument *mParent;
    pagenode mPageNode;
    FaxDocument::DocumentType mType;
};

FaxDocument::FaxDocument(const QString &fileName, DocumentType type)
    : d(new Private(this))
{
    d->mPageNode.filename = fileName;
    d->mPageNode.strips = nullptr;
    d->mPageNode.stripnum = 0;
    d->mPageNode.lsbfirst = 0;
    d->mPageNode.vres = 1;
    d->mPageNode.inverse = 0;
    d->mPageNode.data = nullptr;
    d->mPageNode.dataOrig = nullptr;
    d->mPageNode.imageData = nullptr;
    d->mType = type;

    if (d->mType == G3)
        d->mPageNode.expander = g31expand; // or g32expand?!?
    else if (d->mType == G4)
        d->mPageNode.expander = g4expand;
}

FaxDocument::~FaxDocument()
{
    delete[] d->mPageNode.dataOrig;
    delete[] d->mPageNode.imageData;
    delete d;
}

bool FaxDocument::load()
{
    fax_init_tables();

    bool ok = get_image(&(d->mPageNode));
    if (!ok)
        return false;

    // byte-swapping the image
    int height = d->mPageNode.size.height();
    int bytes_per_line = d->mPageNode.size.width() / 8;

    QByteArray bytes(height * bytes_per_line, 0);
    for (int y = height - 1; y >= 0; --y) {
        quint32 offset = y * bytes_per_line;
        quint32 *source = reinterpret_cast<quint32 *>(d->mPageNode.imageData + offset);
        quint32 *dest = reinterpret_cast<quint32 *>(bytes.data() + offset);
        for (int x = (bytes_per_line / 4) - 1; x >= 0; --x) {
            quint32 dv = 0, sv = *source;
            for (int bit = 32; bit > 0; --bit) {
                dv <<= 1;
                dv |= sv & 1;
                sv >>= 1;
            }
            *dest = dv;
            ++dest;
            ++source;
        }
    }

    // convert it into a QImage
    QImage img((uchar *)bytes.data(), d->mPageNode.size.width(), d->mPageNode.size.height(), QImage::Format_MonoLSB);
    img.setColor(0, qRgb(255, 255, 255));
    img.setColor(1, qRgb(0, 0, 0));

    d->mPageNode.image = img.copy().scaled(img.width(), img.height() * 1.5);

    return true;
}

QImage FaxDocument::image() const
{
    return d->mPageNode.image;
}