kis_asl_reader_utils.h File Reference

#include "psd.h"
#include "psd_utils.h"
#include <algorithm>
#include <stdexcept>
#include <string>
#include <QtEndian>
#include <kis_debug.h>

Go to the source code of this file.

Classes
struct	KisAslReaderUtils::ASLParseException

Namespaces
namespace	KisAslReaderUtils

Macros
#define	GARBAGE_VALUE_MARK   999
#define	SAFE_READ_EX(byteOrder, device, varname)
#define	SAFE_READ_SIGNATURE_EX(byteOrder, device, varname, expected)

Functions
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString	KisAslReaderUtils::readFixedString (QIODevice &device)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString	KisAslReaderUtils::readPascalString (QIODevice &device)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString	KisAslReaderUtils::readStringCommon (QIODevice &device, int length)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString	KisAslReaderUtils::readUnicodeString (QIODevice &device)
template<psd_byte_order byteOrder = psd_byte_order::psdBigEndian>
QString	KisAslReaderUtils::readVarString (QIODevice &device)
template<typename T , size_t S>
bool	TRY_READ_SIGNATURE_2OPS_EX (psd_byte_order byteOrder, QIODevice &device, const std::array< T, S > &expected1, const std::array< T, S > &expected2)
template<psd_byte_order byteOrder, typename T , size_t S>
bool	TRY_READ_SIGNATURE_2OPS_EX (QIODevice &device, const std::array< T, S > &expected1, const std::array< T, S > &expected2)

Macro Definition Documentation

GARBAGE_VALUE_MARK

#define GARBAGE_VALUE_MARK   999

Default value for variable read from a file

Definition at line 26 of file kis_asl_reader_utils.h.

SAFE_READ_EX

#define SAFE_READ_EX	(		byteOrder,
			device,
			varname )

Value:

    if (!psdread<byteOrder>(device, varname)) {                                                                                                                \
        QString msg = QString("Failed to read \'%1\' tag!").arg(#varname);                                                                                     \
        throw KisAslReaderUtils::ASLParseException(msg);                                                                                                       \
    }

Definition at line 45 of file kis_asl_reader_utils.h.

#define SAFE_READ_EX(byteOrder, device, varname)                                                                                                               \
    if (!psdread<byteOrder>(device, varname)) {                                                                                                                \
        QString msg = QString("Failed to read \'%1\' tag!").arg(#varname);                                                                                     \
        throw KisAslReaderUtils::ASLParseException(msg);                                                                                                       \
    }

SAFE_READ_SIGNATURE_EX

#define SAFE_READ_SIGNATURE_EX	(		byteOrder,
			device,
			varname,
			expected )

Value:

    if (!psdread<byteOrder>(device, varname) || varname != expected) {                                                                                         \
        QString msg = QString(                                                                                                                                 \
                          "Failed to check signature \'%1\' tag!\n"                                                                                            \
                          "Value: \'%2\' Expected: \'%3\'")                                                                                                    \
                          .arg(#varname)                                                                                                                       \
                          .arg(varname)                                                                                                                        \
                          .arg(expected);                                                                                                                      \
        throw KisAslReaderUtils::ASLParseException(msg);                                                                                                       \
    }

Definition at line 51 of file kis_asl_reader_utils.h.

#define SAFE_READ_SIGNATURE_EX(byteOrder, device, varname, expected)                                                                                           \
    if (!psdread<byteOrder>(device, varname) || varname != expected) {                                                                                         \
        QString msg = QString(                                                                                                                                 \
                          "Failed to check signature \'%1\' tag!\n"                                                                                            \
                          "Value: \'%2\' Expected: \'%3\'")                                                                                                    \
                          .arg(#varname)                                                                                                                       \
                          .arg(varname)                                                                                                                        \
                          .arg(expected);                                                                                                                      \
        throw KisAslReaderUtils::ASLParseException(msg);                                                                                                       \
    }

Function Documentation

TRY_READ_SIGNATURE_2OPS_EX() [1/2]

template<typename T , size_t S>

bool TRY_READ_SIGNATURE_2OPS_EX ( psd_byte_order byteOrder, QIODevice & device, const std::array< T, S > & expected1, const std::array< T, S > & expected2 )

inline

Definition at line 91 of file kis_asl_reader_utils.h.

{
    switch (byteOrder) {
    case psd_byte_order::psdLittleEndian:
        return TRY_READ_SIGNATURE_2OPS_EX<psd_byte_order::psdLittleEndian>(device, expected1, expected2);
    default:
        return TRY_READ_SIGNATURE_2OPS_EX<psd_byte_order::psdBigEndian>(device, expected1, expected2);
    }
}

References psdLittleEndian.

TRY_READ_SIGNATURE_2OPS_EX() [2/2]

template<psd_byte_order byteOrder, typename T , size_t S>

bool TRY_READ_SIGNATURE_2OPS_EX ( QIODevice & device, const std::array< T, S > & expected1, const std::array< T, S > & expected2 )

inline

Definition at line 63 of file kis_asl_reader_utils.h.

{
    QByteArray bytes = device.peek(S);
 
    if (byteOrder == psd_byte_order::psdLittleEndian) {
        std::reverse(bytes.begin(), bytes.end());
    }
 
    if (bytes.size() != S) {
        return false;
    }
 
    // If read successfully, adjust current position of the io device
 
    if (std::equal(bytes.constBegin(), bytes.constEnd(), expected1.begin()) 
        || std::equal(bytes.constBegin(), bytes.constEnd(), expected2.begin())) {
        // read, not seek, to support sequential devices
        auto bytesRead = psdreadBytes(device, S);
        if (bytesRead.size() == S) {
            return true;
        }
    }
 
    dbgFile << "Photoshop signature verification failed! Got: " << bytes.toHex() << "(" << QString(bytes) << ")";
    return false;
}

References dbgFile, psdLittleEndian, psdreadBytes(), and S.