be_image_bmp.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_IMAGE_BMP__
#define __BE_IMAGE_BMP__
 
#include <be_image_image.h>
 
namespace BiometricEvaluation
{
        namespace Image
        {
                class BMP : public Image
                {
                public:
                        struct ColorTableEntry
                        {
                                uint8_t         red;
                                uint8_t         green;
                                uint8_t         blue;
                                uint8_t         reserved;
                        };
                        using ColorTableEntry = struct ColorTableEntry;
                        using ColorTable = std::vector<ColorTableEntry>;
 
                        BMP(
                            const uint8_t *data,
                            const uint64_t size,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        BMP(
                            const Memory::uint8Array &data,
                            const std::string &identifier = "",
                            const statusCallback_t &statusCallback =
                                Image::defaultStatusCallback);
 
                        ~BMP() = default;
 
                        Memory::AutoArray<uint8_t>
                        getRawData()
                            const;
 
                        Memory::AutoArray<uint8_t>
                        getRawGrayscaleData(
                            uint8_t depth)
                            const;
 
                        static bool
                        isBMP(
                            const uint8_t *data,
                            uint64_t size);
                protected:
 
                private:
                        typedef struct
                        {
                                uint16_t magic;
                                uint32_t size;
                                uint16_t reserved1;
                                uint16_t reserved2;
                                uint32_t startingAddress;
                        } BMPHeader;
 
                        typedef struct
                        {
                                uint32_t headerSize;
                                int32_t width;
                                int32_t height;
                                uint16_t colorPanes;
                                uint16_t bitsPerPixel;
                                uint32_t compressionMethod;
                                uint32_t bitmapSize;
                                uint32_t xResolution;
                                uint32_t yResolution;
                                uint32_t numberOfColors;
                                uint32_t numberOfImportantColors;
                        } BITMAPINFOHEADER;
 
                        static void
                        getBMPHeader(
                            const uint8_t * const buf,
                            uint64_t bufsz,
                            BMPHeader *header);
 
                        static void
                        getDIBHeader(
                            const uint8_t * const buf,
                            uint64_t bufsz,
                            BITMAPINFOHEADER *header);
 
                        void
                        getColorTable(
                            const uint8_t *buf,
                            uint64_t bufsz,
                            int count,
                            ColorTable &colorTable);
 
                        void
                        rle8Decoder(
                            const uint8_t *input,
                            uint64_t inputSize,
                            Memory::uint8Array &output,
                            BMPHeader *bmpHeader,
                            BITMAPINFOHEADER *dibHeader) const;
 
                        ColorTable _colorTable{};
                };
 
                #ifndef BI_RGB
                static const uint8_t BI_RGB = 0;
                #endif /* BI_RGB */
                #ifndef BI_RLE8
                static const uint8_t BI_RLE8 = 1;
                #endif /* BI_RLE8 */
 
        }
}
#endif