kis_abr_brush_collection.cpp File Reference

#include <QtEndian>
#include "kis_abr_brush_collection.h"
#include "kis_abr_brush.h"
#include <QDomElement>
#include <QFile>
#include <QImage>
#include <QPoint>
#include <QColor>
#include <QByteArray>
#include <kis_debug.h>
#include <QString>
#include <QBuffer>
#include <QFileInfo>
#include <KoMD5Generator.h>
#include <klocalizedstring.h>
#include <KoColor.h>

Go to the source code of this file.

Classes
struct	AbrInfo

Functions
static bool	abr_reach_8BIM_section (QDataStream &abr, const QString name)
static bool	abr_read_content (QDataStream &abr, AbrInfo *abr_hdr)
static QString	abr_read_ucs2_text (QDataStream &abr)
static bool	abr_supported_content (AbrInfo *abr_hdr)
static QString	abr_v1_brush_name (const QString filename, qint32 id)
static QImage	convertToQImage (char *buffer, qint32 width, qint32 height)
	save the QImages as png files to directory image_tests
static qint32	find_sample_count_v6 (QDataStream &abr, AbrInfo *abr_info)
static qint32	rle_decode (QDataStream &abr, char *buffer, qint32 height)

Function Documentation

abr_reach_8BIM_section()

static bool abr_reach_8BIM_section ( QDataStream & abr, const QString name )

static

Definition at line 138 of file kis_abr_brush_collection.cpp.

{
    char tag[4];
    char tagname[5];
    qint32 section_size = 0;
    int r;
 
    // find 8BIMname section
    while (!abr.atEnd()) {
        r = abr.readRawData(tag, 4);
 
        if (r != 4) {
            warnKrita << "Error: Cannot read 8BIM tag ";
            return false;
        }
 
        if (strncmp(tag, "8BIM", 4)) {
            warnKrita << "Error: Start tag not 8BIM but " << (int)tag[0] << (int)tag[1] << (int)tag[2] << (int)tag[3] << " at position " << abr.device()->pos();
            return false;
        }
 
        r = abr.readRawData(tagname, 4);
 
        if (r != 4) {
            warnKrita << "Error: Cannot read 8BIM tag name";
            return false;
        }
        tagname[4] = '\0';
 
        QString s1 = QString::fromLatin1(tagname, 4);
 
        if (!s1.compare(name)) {
            return true;
        }
 
        // long
        abr >> section_size;
        abr.device()->seek(abr.device()->pos() + section_size);
    }
    return true;
}

References s1, and warnKrita.

abr_read_content()

static bool abr_read_content ( QDataStream & abr, AbrInfo * abr_hdr )

static

Definition at line 237 of file kis_abr_brush_collection.cpp.

{
 
    abr >> abr_hdr->version;
    abr_hdr->subversion = 0;
    abr_hdr->count = 0;
 
    switch (abr_hdr->version) {
    case 1:
    case 2:
        abr >> abr_hdr->count;
        break;
    case 6:
        abr >> abr_hdr->subversion;
        abr_hdr->count = find_sample_count_v6(abr, abr_hdr);
        break;
    default:
        // unknown versions
        break;
    }
    // next bytes in abr are samples data
 
    return true;
}

References AbrInfo::count, find_sample_count_v6(), AbrInfo::subversion, and AbrInfo::version.

abr_read_ucs2_text()

static QString abr_read_ucs2_text ( QDataStream & abr )

static

Definition at line 263 of file kis_abr_brush_collection.cpp.

{
    quint32 name_size;
    quint32 buf_size;
    uint   i;
    /* two-bytes characters encoded (UCS-2)
    *  format:
    *   long : size - number of characters in string
    *   data : zero terminated UCS-2 string
    */
 
    // long
    abr >> name_size;
    if (name_size == 0) {
        return QString();
    }
 
    //buf_size = name_size * 2;
    buf_size = name_size;
 
    //name_ucs2 = (char*) malloc (buf_size * sizeof (char));
    //name_ucs2 = new char[buf_size];
 
    ushort * name_ucs2 = new ushort[buf_size];
    for (i = 0; i < buf_size ; i++) {
        //* char*/
        //abr >> name_ucs2[i];
 
        // I will use ushort as that is input to fromUtf16
        abr >>  name_ucs2[i];
    }
    QString name_utf8 = QString::fromUtf16(name_ucs2, buf_size);
    delete [] name_ucs2;
 
    return name_utf8;
}

abr_supported_content()

static bool abr_supported_content ( AbrInfo * abr_hdr )

static

Definition at line 123 of file kis_abr_brush_collection.cpp.

{
    switch (abr_hdr->version) {
    case 1:
    case 2:
        return true;
        break;
    case 6:
        if (abr_hdr->subversion == 1 || abr_hdr->subversion == 2)
            return true;
        break;
    }
    return false;
}

References AbrInfo::subversion, and AbrInfo::version.

abr_v1_brush_name()

static QString abr_v1_brush_name ( const QString filename, qint32 id )

static

Definition at line 114 of file kis_abr_brush_collection.cpp.

{
    QString result = filename;
    int pos = filename.lastIndexOf('.');
    result.remove(pos, 4);
    QTextStream(&result) << "_" << id;
    return result;
}

convertToQImage()

static QImage convertToQImage ( char * buffer, qint32 width, qint32 height )

static

save the QImages as png files to directory image_tests

Definition at line 38 of file kis_abr_brush_collection.cpp.

{
    // create 8-bit indexed image
    QImage img(width, height, QImage::Format_RGB32);
    int pos = 0;
    int value = 0;
    for (int y = 0; y < height; y++) {
        QRgb *pixel = reinterpret_cast<QRgb *>(img.scanLine(y));
        for (int x = 0; x < width; x++, pos++) {
            value = 255 - buffer[pos];
            pixel[x] = qRgb(value, value , value);
        }
 
    }
 
    return img;
}

References value().

find_sample_count_v6()

static qint32 find_sample_count_v6 ( QDataStream & abr, AbrInfo * abr_info )

static

Definition at line 180 of file kis_abr_brush_collection.cpp.

{
    qint64 origin;
    qint32 sample_section_size;
    qint32 sample_section_end;
    qint32 samples = 0;
    qint32 data_start;
 
    qint32 brush_size;
    qint32 brush_end;
 
    if (!abr_supported_content(abr_info))
        return 0;
 
    origin = abr.device()->pos();
 
    if (!abr_reach_8BIM_section(abr, "samp")) {
        // reset to origin
        abr.device()->seek(origin);
        return 0;
    }
 
    // long
    abr >> sample_section_size;
    sample_section_end = sample_section_size + abr.device()->pos();
 
    if(sample_section_end < 0 || sample_section_end > abr.device()->size())
        return 0;
 
    data_start = abr.device()->pos();
 
    while ((!abr.atEnd()) && (abr.device()->pos() < sample_section_end)) {
        // read long
        abr >> brush_size;
        brush_end = brush_size;
        // complement to 4
        while (brush_end % 4 != 0) brush_end++;
 
        qint64 newPos = abr.device()->pos() + brush_end;
        if(newPos > 0 && newPos < abr.device()->size()) {
            abr.device()->seek(newPos);
        }
        else
            return 0;
 
        samples++;
    }
 
    // set stream to samples data
    abr.device()->seek(data_start);
 
    //dbgKrita <<"samples : "<< samples;
    return samples;
}

References abr_reach_8BIM_section(), and abr_supported_content().

rle_decode()

static qint32 rle_decode ( QDataStream & abr, char * buffer, qint32 height )

static

Definition at line 56 of file kis_abr_brush_collection.cpp.

{
    qint32 n;
    char ptmp;
    char ch;
    int i, j, c;
    short *cscanline_len;
    char *data = buffer;
 
    // read compressed size foreach scanline
    cscanline_len = new short[ height ];
    for (i = 0; i < height; i++) {
        // short
        abr >> cscanline_len[i];
    }
 
    // unpack each scanline data
    for (i = 0; i < height; i++) {
        for (j = 0; j < cscanline_len[i];) {
            // char
            if (!abr.device()->getChar(&ptmp)) {
                break;
            }
            n = ptmp;
 
            j++;
            if (n >= 128)     // force sign
                n -= 256;
            if (n < 0) {      // copy the following char -n + 1 times
                if (n == -128)  // it's a nop
                    continue;
                n = -n + 1;
                // char
                if (!abr.device()->getChar(&ch)) {
                    break;
                }
 
                j++;
                for (c = 0; c < n; c++, data++) {
                    *data = ch;
                }
            }
            else {
                // read the following n + 1 chars (no compr)
                for (c = 0; c < n + 1; c++, j++, data++) {
                    // char
                    if (!abr.device()->getChar(data))  {
                        break;
                    }
                }
            }
        }
    }
    delete [] cscanline_len;
    return 0;
}