Atil.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
namespace Atil
{
 
typedef signed char Int8;
typedef unsigned char UInt8;
typedef signed short Int16;
typedef unsigned short UInt16;
typedef signed int Int32;
typedef unsigned int UInt32;
typedef signed __int64 Int64;
typedef unsigned __int64 UInt64;
 
class ARX_API ColorModelInterface
{
public:
    virtual ~ColorModelInterface();
};
 
class ARX_API DataModelAttributes
{
public:
    enum BitsPerPixel
    {
        k1,
        k8,
        k16,
        k32,
        k64,
        k128,
    };
 
    enum DataModelType
    {
        kDataModel,
        kRgbModel,
        kPalettedRgbModel,
        kGrayModel,
        kBitonalModel,
        kRgbModel5b,
        kRgbModel10,
        kRgbModel16i,
        kRgbModel16f,
        kRgbModel32f,
        kGrayModel16i,
        kGrayModel16f,
        kGrayModel32f,
        kGrayModel32i,
    };
 
    enum PixelType 
    {
        kData1,
        kData8,
        kData16,
        kData32,
        kData64,
        kData128,
        kBitonal,
        kGray,
        kPalettedRgb,
        kRgba,
        kBgra,
        kGray16i,
        kGray16f,
        kGray32f,
        kRgba5b,
        kBgra5b,
        kRgba10i,
        kBgra10i,
        kRgba16i,
        kBgra16i,
        kRgba16f,
        kBgra16f,
        kRgba32f,
        kBgra32f,
        kGray32i,
        kRgba32i,
        kBgra32i,
    };
 
    enum DataType
    {
        kUnknown,
        kUnsignedShort,
        kSignedShort,
        kUnsignedInteger,
        kSignedInteger,
        kFloat16,
        kFloat,
        kBitFields
    };
    enum BitFields
    {
        kFull,
        k5551,
        k565,
    };
 
    enum ChannelOrder
    {
        kSingleChannel,
        kRedGreenBlueAlpha,
        kBlueGreenRedAlpha,
    };
};
 
typedef unsigned char Data8;
typedef unsigned short Data16;
typedef unsigned int Data32;
typedef unsigned __int64 Data64;
 
enum Orientation  
{
    kTopDownLeftRight,
    kTopDownRightLeft,
    kBottomUpLeftRight,
    kBottomUpRightLeft,
    kLeftRightTopDown,
    kRightLeftTopDown,
    kLeftRightBottomUp,
    kRightLeftBottomUp
};
 
typedef wchar_t Byte;
 
class ARX_API DataModel
{
public:
    enum TileSize {
        k64x64,
        k128x128,
        k256x256,
        k512x512,
        k1024x1024,
        kUnspecified,
        kDefault,
    };
    DataModel();
    DataModel(DataModelAttributes::DataType, DataModelAttributes::BitsPerPixel, int);
    virtual ~DataModel();
    static int bytesPerRow(Int32, DataModelAttributes::BitsPerPixel);
    virtual bool isCompatibleTileSize(DataModel::TileSize) const;
    virtual DataModelAttributes::BitFields bitFields() const;
    virtual DataModelAttributes::ChannelOrder channelOrder() const;
    virtual DataModel* clone() const;
    virtual DataModel::TileSize defaultTileSize() const;
    virtual DataModelAttributes::DataType dataType() const;
    virtual DataModelAttributes::PixelType pixelType() const;
    virtual DataModelAttributes::DataModelType dataModelType() const;
    virtual int bitsUsedPerPixel() const;
    virtual DataModelAttributes::BitsPerPixel bitsPerPixel() const;
    virtual bool isCompatibleDataSize(DataModelAttributes::BitsPerPixel dataSize) const;
    virtual bool operator==(const DataModel& dm) const;
    virtual bool operator!=(const DataModel& dm) const;
};
 
class ARX_API RgbModel : public DataModel, public ColorModelInterface
{
public:
    RgbModel();
    RgbModel( int );
    ~RgbModel();
    int pixelType();
};
 
class ARX_API RgbColor
{
public:
    RgbColor();
    RgbColor(Data32);
    RgbColor(Data8, Data8, Data8);
    RgbColor(Data8, Data8, Data8, Data8);
 
    union {
        struct {
            Data8 red;
            Data8 green;
            Data8 blue;
            Data8 alpha;
        } rgba;
 
        struct {
            Data8 blue;
            Data8 green;
            Data8 red;
            Data8 alpha;
        } bgra;
        Data32 packed;
    };
 
};
 
class ARX_API RgbPaletteModel : public RgbModel
{
public:
    RgbPaletteModel(int = 256);
    RgbPaletteModel(int, RgbColor const *);
    RgbPaletteModel(int, int, RgbColor const *);
    virtual ~RgbPaletteModel();
 
    virtual void setEntries(int, int, const RgbColor*);
};
 
class ARX_API RgbGrayModel : public RgbModel
{
public:
    RgbGrayModel(void);
    virtual ~RgbGrayModel(void);
};
 
 
class ARX_API ImagePixel
{
public:
    ImagePixel(DataModelAttributes::PixelType = DataModelAttributes::kData1);
    const ImagePixel& setToZero();
    bool operator!=(const ImagePixel&) const;
    bool operator==(const ImagePixel&) const;
    DataModelAttributes::PixelType type;
};
 
class ARX_API Size
{
public:
        Size( int width, int height );
};
 
class ARX_API Offset
{
public:
        Offset( int , int );
};
 
class ARX_API RowProviderInterface
{
public:
 
        Atil::DataModel dataModel();
        Atil::Size size();
};
 
class ARX_API FileReadDescriptor
{
};
 
class ARX_API Image
{
public:
    Image(void);
    Image(const Image &);
    Image(const Atil::Size&, const Atil::DataModel*, Atil::ImagePixel, DataModel::TileSize = DataModel::kUnspecified);
    Image(void*, int, int, const Atil::Size&, const Atil::DataModel*);
    Image(RowProviderInterface*, DataModel::TileSize = DataModel::kUnspecified);
    Image(RowProviderInterface*, Atil::Orientation, DataModel::TileSize = DataModel::kUnspecified);
    Image(FileReadDescriptor&, DataModel::TileSize = DataModel::kUnspecified);
    ~Image();
    bool isValid();
    Atil::Size size();
    Atil::RowProviderInterface* read( const Atil::Size&, const Atil::Offset&, Atil::Orientation  ) const;
    Atil::RowProviderInterface* read(const Atil::Size&, const Atil::Offset&) const;
 
};
 
class ARX_API ImageFormatCodec
{
public:
        ImageFormatCodec();
};
 
class StringBufferImpl;
class ARX_API StringBuffer
{
public:
    enum CharacterType  
    {
        kASCII,
        kUTF_8,
        kUTF_16,
        kUTF_32,
        kMBCS,
    };
 
    StringBuffer(int, const Atil::Byte *, Atil::StringBuffer::CharacterType = Atil::StringBuffer::kASCII);
    StringBuffer();
    StringBuffer(int, Atil::StringBuffer::CharacterType = Atil::StringBuffer::kASCII);
    StringBuffer(const StringBuffer&);
    virtual ~StringBuffer();
    virtual CharacterType type() const;
    virtual int numDataBytes() const;
    virtual const Byte* data() const;
    virtual StringBuffer& set(const StringBuffer& string);
    virtual StringBuffer& set(int, const Byte*, CharacterType = StringBuffer::kASCII);
 
private:
    StringBufferImpl* m_pImpl;
};
 
class ARX_API FileSpecifier
{
public:
    enum Type  
    {
        kFilePath
    };
 
    FileSpecifier( Atil::StringBuffer, Atil::FileSpecifier::Type );
    virtual ~FileSpecifier();
    static bool isCompatibleFormatCodec( Atil::ImageFormatCodec*, Atil::DataModel*,  Atil::Size );
};
 
class ARX_API FormatCodecPropertyInterface
{
public:
    enum PropertyIdentifier 
        { 
                kCompression
        };
 
        FormatCodecPropertyInterface();
        virtual bool isRequired();
};
 
class ARX_API FormatCodecIntProperty: public Atil::FormatCodecPropertyInterface
{
public:
        FormatCodecIntProperty();
 
        void getPropertyLimits( int& min, int& max );
        void setValue( int );
};
 
class ARX_API FormatCodecPropertySetIterator
{
public:
        void start();
        bool endOfList();
        void step();
        Atil::FormatCodecPropertyInterface* openProperty();
        void closeProperty();
};
 
class ARX_API FileWriteDescriptor
{
public:
    FileWriteDescriptor( Atil::ImageFormatCodec* );
    virtual ~FileWriteDescriptor();
 
    static bool isCompatibleFormatCodec( Atil::ImageFormatCodec*, Atil::DataModel*,  Atil::Size );
    bool setFileSpecifier(  Atil::FileSpecifier );
    void createImageFrame( Atil::DataModel, Atil::Size );
    Atil::FormatCodecPropertyInterface * getProperty( Atil::FormatCodecPropertyInterface::PropertyIdentifier );
    void setProperty( Atil::FormatCodecPropertyInterface* );
    Atil::FormatCodecPropertySetIterator* newPropertySetIterator();
    int writeImageFrame( Atil::RowProviderInterface * );
};
 
class ARX_API ATILException
{
public:
    virtual ~ATILException();
        const Atil::StringBuffer * getMessage();
};
 
}
 
//==============================================================================
 
class ARX_API BmpFormatCodec : public Atil::ImageFormatCodec
{
public:
        BmpFormatCodec();
};
 
class ARX_API JfifFormatCodec : public Atil::ImageFormatCodec
{
public:
        JfifFormatCodec();
};
 
class ARX_API PngFormatCodec : public Atil::ImageFormatCodec
{
public:
        PngFormatCodec();
};
 
class ARX_API TiffFormatCodec : public Atil::ImageFormatCodec
{
public:
        TiffFormatCodec();
};
 
class ARX_API PngCompressionType
{
public:
    enum Compression 
        { 
                kHigh
        };
};
 
class ARX_API PngCompression: public Atil::FormatCodecPropertyInterface
{
public:
        void selectCompression( PngCompressionType::Compression );
};
 
class ARX_API TiffCompressionType
{
public:
    enum Compression 
        { 
                kCCITT_FAX4,
                kLZW, 
                kNone
        };
};
 
class ARX_API TiffCompression: public Atil::FormatCodecPropertyInterface
{
public:
        bool selectCompression( TiffCompressionType::Compression );
};