iBMP.h

Go to the documentation of this file.

/*
imagen - Simple object-oriented imaging library
Copyright (C) 2012 Mark D. Procarione

imagen is free software: you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation, either
version 3 of the License, or (at your option) any later version.

imagen 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 General Public License for more details.
*/

#ifndef __IBMP_H__
#define __IBMP_H__

#include "imagen.h"

#ifdef IMAGEN_BMP

#include "iAbstractImage.h"

namespace imagen
{

    class iBMP : public iAbstractImage
    {
        private:
            #pragma pack(1)

            struct BITMAPFILEHEADER
            {
                BITMAPFILEHEADER();
                void clear();

                iWORD  FileType;     // 00h  Header field magic number
                iDWORD FileSize;     // 02h  Complete file size in bytes
                iWORD  Reserved1;    // 06h  Reserved, application specific
                iWORD  Reserved2;    // 08h  Reserved, application specific
                iDWORD BitmapOffset; // 0Ah  Offset from start of header to image data
            };

            struct BITMAPCOREHEADER
            {
                BITMAPCOREHEADER();
                void clear();

                iDWORD Size;         // 00h  Size of the header in bytes
                iWORD  Width;        // 04h  Image width in pixels
                iWORD  Height;       // 06h  Image height in pixels
                iWORD  Planes;       // 08h  Number of color planes
                iWORD  BitsPerPixel; // 0Ah  Number of bits per pixel
            };

            struct BITMAPINFOHEADER
            {
                BITMAPINFOHEADER();
                void clear();

                iDWORD Size;            // 00h  Size of the header in bytes
                iLONG  Width;           // 04h  Image width in pixels
                iLONG  Height;          // 08h  Image height in pixels
                iWORD  Planes;          // 0Ch  Number of color planes
                iWORD  BitsPerPixel;    // 0Eh  Number of bits per pixel
                iDWORD Compression;     // 10h  Compression type
                iDWORD SizeOfBitmap;    // 14h  Size of bitmap in bytes
                iLONG  XResolution;     // 18h  Horizontal resolution, in pixels per meter
                iLONG  YResolution;     // 1Ch  Vertical resolution, in pixels per meter
                iDWORD ColorsUsed;      // 20h  Number of color indices
                iDWORD ColorsImportant; // 24h  Number of required color indices
            };

            struct BITMAPV4HEADER : BITMAPINFOHEADER
            {
                BITMAPV4HEADER();
                void clear();

                iDWORD RedMask;         // 28h  Red component bit mask
                iDWORD GreenMask;       // 2Ch  Green component bit mask
                iDWORD BlueMask;        // 30h  Blue component bit mask
                iDWORD AlphaMask;       // 34h  Alpha component bit mask
                iDWORD CSType;          // 38h  Color space type
                iLONG  RedX;            // 3Ch  X coordinate of red endpoint
                iLONG  RedY;            // 40h  Y coordinate of red endpoint
                iLONG  RedZ;            // 44h  Z coordinate of red endpoint
                iLONG  GreenX;          // 48h  X coordinate of green endpoint
                iLONG  GreenY;          // 4Ch  Y coordinate of green endpoint
                iLONG  GreenZ;          // 50h  Z coordinate of green endpoint
                iLONG  BlueX;           // 54h  X coordinate of blue endpoint
                iLONG  BlueY;           // 58h  Y coordinate of blue endpoint
                iLONG  BlueZ;           // 5Ch  Z coordinate of blue endpoint
                iDWORD GammaRed;        // 60h  Gamma red coordinate scale value
                iDWORD GammaGreen;      // 64h  Gamma green coordinate scale value
                iDWORD GammaBlue;       // 68h  Gamma blue coordinate scale value
            };

            struct BITMAPV5HEADER : BITMAPV4HEADER
            {
                BITMAPV5HEADER();
                void clear();

                iDWORD Intent;          // 6Ch  Rendering intent
                iDWORD ProfileData;     // 70h  Offset from start of BITMAPV5HEADER to start of profile data
                iDWORD ProfileSize;     // 74h  Size of profile data in bytes
                iDWORD Reserved;        // 78h  Reserved member
            };
            #pragma pack()

        public:
            enum BMPCompressFmt
            {
                BI_RGB = 0,
                BI_RLE8 = 1,
                BI_RLE4 = 2,
                BI_BITFIELDS = 3,
                BI_JPEG = 4,
                BI_PNG = 5
            };

            enum BMPRenderingIntent
            {
                RI_COLORIMETRIC = 0,
                RI_BUSINESS = 1,
                RI_GRAPHICS = 2,
                RI_IMAGES = 3
            };

            enum BMPColorSpace
            {
                CS_CALIBRATED_RGB = 0,
                CS_sRGB = 1,
                CS_CMYK = 2
            };

        public:
            iBMP();


            iBMP( const iBMP &img );

            iBMP( const iAbstractImage &img );


            iBMP( int w, int h, iImageFormat f );


            iBMP( Iubyte *d, int w, int h, iImageFormat f, int b );


            iBMP( const char *filename );


            iBMP( Iubyte *buf, int len );


            iBMP( iDataStream *s );

            ~iBMP();

            void clear();

            bool isFormatSupported( iImageFormat fmt ) const;

            static bool isValid( iDataStream *s );

            iBMP &operator=( const iBMP &img );

            iBMP &operator=( const iAbstractImage &img );

        protected:
            void init();
            bool loadImage();
            bool saveImage();

        private:
            bool readFileHeader();
            bool readBitmapHeader();
            bool validateHeader();
            bool readImageData();

            bool readColTable();

            bool writeFileHeader();
            bool writeBitmapHeader();
            bool writeImageData();

            bool writeColTable();

        private:
            BITMAPFILEHEADER fileheader;
            int bmpbits;
    };
}

#endif // IMAGEN_BMP

#endif // __IBMP_H__