.bmp file format: C++98/STL parsing library

#ifndef BMP_H_
#define BMP_H_

// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild

#include "kaitai/kaitaistruct.h"
#include <stdint.h>
#include <vector>

#if KAITAI_STRUCT_VERSION < 9000L
#error "Incompatible Kaitai Struct C++/STL API: version 0.9 or later is required"
#endif

/**
 * The **BMP file format**, also known as **bitmap image file** or **device independent
 * bitmap (DIB) file format** or simply a **bitmap**, is a raster graphics image file
 * format used to store bitmap digital images, independently of the display
 * device (such as a graphics adapter), especially on Microsoft Windows
 * and OS/2 operating systems.
 * 
 * ## Samples
 * 
 * Great collection of various BMP sample files:
 * [**BMP Suite Image List**](
 *   http://entropymine.com/jason/bmpsuite/bmpsuite/html/bmpsuite.html
 * ) (by Jason Summers)
 * 
 * If only there was such a comprehensive sample suite for every file format! It's like
 * a dream for every developer of any binary file format parser. It contains a lot of
 * different types and variations of BMP files, even the tricky ones, where it's not clear
 * from the specification how to deal with them (marked there as "**q**uestionable").
 * 
 * If you make a program which will be able to read all the "**g**ood" and "**q**uestionable"
 * BMP files and won't crash on the "**b**ad" ones, it will definitely have one of the most
 * extensive support of BMP files in the universe!
 * 
 * ## BITMAPV2INFOHEADER and BITMAPV3INFOHEADER
 * 
 * A beneficial discussion on Adobe forum (archived):
 * [**Invalid BMP Format with Alpha channel**](
 *   https://web.archive.org/web/20150127132443/https://forums.adobe.com/message/3272950
 * )
 * 
 * In 2010, someone noticed that Photoshop generated BMP with an odd type of header. There wasn't
 * any documentation available for this header at the time (and still isn't).
 * However, Chris Cox (former Adobe employee) claimed that they hadn't invented any type
 * of proprietary header and everything they were writing was taken directly
 * from the Microsoft documentation.
 * 
 * It showed up that the unknown header was called BITMAPV3INFOHEADER.
 * Although Microsoft has apparently requested and verified the use of the header,
 * the documentation on MSDN has probably got lost and they have probably
 * forgotten about this type of header.
 * 
 * This is the only source I could find about these structures, so we could't rely
 * on it so much, but I think supporting them as a read-only format won't harm anything.
 * Due to the fact that it isn't documented anywhere else, most applications don't support it.
 * 
 * All Windows headers at once (including mentioned BITMAPV2INFOHEADER and BITMAPV3INFOHEADER):
 * 
 * ![Bitmap headers overview](
 *   https://web.archive.org/web/20190527043845/https://forums.adobe.com/servlet/JiveServlet/showImage/2-3273299-47801/BMP_Headers.png
 * )
 * 
 * ## Specs
 *  * [Bitmap Storage (Windows Dev Center)](
 *      https://learn.microsoft.com/en-us/windows/win32/gdi/bitmap-storage
 *    )
 *     * BITMAPFILEHEADER
 *     * BITMAPINFOHEADER
 *     * BITMAPV4HEADER
 *     * BITMAPV5HEADER
 *  * [OS/2 Bitmap File Format](
 *       https://www.fileformat.info/format/os2bmp/egff.htm
 *    )
 *     * BITMAPFILEHEADER (OS2BMPFILEHEADER)
 *     * BITMAPCOREHEADER (OS21XBITMAPHEADER)
 *     * OS22XBITMAPHEADER
 *  * [Microsoft Windows Bitmap](
 *       http://netghost.narod.ru/gff/graphics/summary/micbmp.htm
 *    )
 *     * BITMAPFILEHEADER (WINBMPFILEHEADER)
 *     * BITMAPCOREHEADER (WIN2XBITMAPHEADER)
 *     * BITMAPINFOHEADER (WINNTBITMAPHEADER)
 *     * BITMAPV4HEADER (WIN4XBITMAPHEADER)
 */

class bmp_t : public kaitai::kstruct {

public:
    class cie_xyz_t;
    class rgb_record_t;
    class bitmap_v5_extension_t;
    class color_mask_t;
    class bitmap_v4_extension_t;
    class bitmap_info_extension_t;
    class fixed_point_2_dot_30_t;
    class bitmap_t;
    class bitmap_header_t;
    class os2_2x_bitmap_extension_t;
    class fixed_point_16_dot_16_t;
    class color_table_t;
    class file_header_t;
    class bitmap_info_t;

    enum intent_t {
        INTENT_BUSINESS = 1,
        INTENT_GRAPHICS = 2,
        INTENT_IMAGES = 4,
        INTENT_ABS_COLORIMETRIC = 8
    };

    enum color_space_t {
        COLOR_SPACE_CALIBRATED_RGB = 0,
        COLOR_SPACE_PROFILE_LINKED = 1279872587,
        COLOR_SPACE_PROFILE_EMBEDDED = 1296188740,
        COLOR_SPACE_WINDOWS = 1466527264,
        COLOR_SPACE_S_RGB = 1934772034
    };

    enum os2_rendering_t {
        OS2_RENDERING_NO_HALFTONING = 0,
        OS2_RENDERING_ERROR_DIFFUSION = 1,
        OS2_RENDERING_PANDA = 2,
        OS2_RENDERING_SUPER_CIRCLE = 3
    };

    enum header_type_t {
        HEADER_TYPE_BITMAP_CORE_HEADER = 12,
        HEADER_TYPE_BITMAP_INFO_HEADER = 40,
        HEADER_TYPE_BITMAP_V2_INFO_HEADER = 52,
        HEADER_TYPE_BITMAP_V3_INFO_HEADER = 56,
        HEADER_TYPE_OS2_2X_BITMAP_HEADER = 64,
        HEADER_TYPE_BITMAP_V4_HEADER = 108,
        HEADER_TYPE_BITMAP_V5_HEADER = 124
    };

    enum compressions_t {
        COMPRESSIONS_RGB = 0,
        COMPRESSIONS_RLE8 = 1,
        COMPRESSIONS_RLE4 = 2,
        COMPRESSIONS_BITFIELDS = 3,
        COMPRESSIONS_JPEG = 4,
        COMPRESSIONS_PNG = 5,
        COMPRESSIONS_ALPHA_BITFIELDS = 6
    };

    enum os2_compressions_t {
        OS2_COMPRESSIONS_RGB = 0,
        OS2_COMPRESSIONS_RLE8 = 1,
        OS2_COMPRESSIONS_RLE4 = 2,
        OS2_COMPRESSIONS_HUFFMAN_1D = 3,
        OS2_COMPRESSIONS_RLE24 = 4
    };

    bmp_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = 0, bmp_t* p__root = 0);

private:
    void _read();
    void _clean_up();

public:
    ~bmp_t();

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-ciexyz Source
     */

    class cie_xyz_t : public kaitai::kstruct {

    public:

        cie_xyz_t(kaitai::kstream* p__io, bmp_t::bitmap_v4_extension_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~cie_xyz_t();

    private:
        fixed_point_2_dot_30_t* m_x;
        fixed_point_2_dot_30_t* m_y;
        fixed_point_2_dot_30_t* m_z;
        bmp_t* m__root;
        bmp_t::bitmap_v4_extension_t* m__parent;

    public:
        fixed_point_2_dot_30_t* x() const { return m_x; }
        fixed_point_2_dot_30_t* y() const { return m_y; }
        fixed_point_2_dot_30_t* z() const { return m_z; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_v4_extension_t* _parent() const { return m__parent; }
    };

    class rgb_record_t : public kaitai::kstruct {

    public:

        rgb_record_t(bool p_has_reserved_field, kaitai::kstream* p__io, bmp_t::color_table_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~rgb_record_t();

    private:
        uint8_t m_blue;
        uint8_t m_green;
        uint8_t m_red;
        uint8_t m_reserved;
        bool n_reserved;

    public:
        bool _is_null_reserved() { reserved(); return n_reserved; };

    private:
        bool m_has_reserved_field;
        bmp_t* m__root;
        bmp_t::color_table_t* m__parent;

    public:
        uint8_t blue() const { return m_blue; }
        uint8_t green() const { return m_green; }
        uint8_t red() const { return m_red; }
        uint8_t reserved() const { return m_reserved; }
        bool has_reserved_field() const { return m_has_reserved_field; }
        bmp_t* _root() const { return m__root; }
        bmp_t::color_table_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapv5header Source
     */

    class bitmap_v5_extension_t : public kaitai::kstruct {

    public:

        bitmap_v5_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_v5_extension_t();

    private:
        bool f_has_profile;
        bool m_has_profile;

    public:
        bool has_profile();

    private:
        bool f_profile_data;
        std::string m_profile_data;
        bool n_profile_data;

    public:
        bool _is_null_profile_data() { profile_data(); return n_profile_data; };

    private:

    public:

        /**
         * \sa https://learn.microsoft.com/en-us/windows/win32/wcs/using-structures-in-wcs-1-0 "If the profile is embedded, profile data is the actual profile, and if it is linked, the profile data is the null-terminated file name of the profile. This cannot be a Unicode string. It must be composed exclusively of characters from the Windows character set (code page 1252)."
         */
        std::string profile_data();

    private:
        intent_t m_intent;
        uint32_t m_ofs_profile;
        uint32_t m_len_profile;
        uint32_t m_reserved;
        bmp_t* m__root;
        bmp_t::bitmap_header_t* m__parent;

    public:
        intent_t intent() const { return m_intent; }

        /**
         * The offset, in bytes, from the beginning of the BITMAPV5HEADER structure to the start of the profile data.
         */
        uint32_t ofs_profile() const { return m_ofs_profile; }
        uint32_t len_profile() const { return m_len_profile; }
        uint32_t reserved() const { return m_reserved; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_header_t* _parent() const { return m__parent; }
    };

    class color_mask_t : public kaitai::kstruct {

    public:

        color_mask_t(bool p_has_alpha_mask, kaitai::kstream* p__io, kaitai::kstruct* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~color_mask_t();

    private:
        uint32_t m_red_mask;
        uint32_t m_green_mask;
        uint32_t m_blue_mask;
        uint32_t m_alpha_mask;
        bool n_alpha_mask;

    public:
        bool _is_null_alpha_mask() { alpha_mask(); return n_alpha_mask; };

    private:
        bool m_has_alpha_mask;
        bmp_t* m__root;
        kaitai::kstruct* m__parent;

    public:
        uint32_t red_mask() const { return m_red_mask; }
        uint32_t green_mask() const { return m_green_mask; }
        uint32_t blue_mask() const { return m_blue_mask; }
        uint32_t alpha_mask() const { return m_alpha_mask; }
        bool has_alpha_mask() const { return m_has_alpha_mask; }
        bmp_t* _root() const { return m__root; }
        kaitai::kstruct* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapv4header Source
     */

    class bitmap_v4_extension_t : public kaitai::kstruct {

    public:

        bitmap_v4_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_v4_extension_t();

    private:
        color_space_t m_color_space_type;
        cie_xyz_t* m_endpoint_red;
        cie_xyz_t* m_endpoint_green;
        cie_xyz_t* m_endpoint_blue;
        fixed_point_16_dot_16_t* m_gamma_red;
        fixed_point_16_dot_16_t* m_gamma_blue;
        fixed_point_16_dot_16_t* m_gamma_green;
        bmp_t* m__root;
        bmp_t::bitmap_header_t* m__parent;

    public:
        color_space_t color_space_type() const { return m_color_space_type; }
        cie_xyz_t* endpoint_red() const { return m_endpoint_red; }
        cie_xyz_t* endpoint_green() const { return m_endpoint_green; }
        cie_xyz_t* endpoint_blue() const { return m_endpoint_blue; }
        fixed_point_16_dot_16_t* gamma_red() const { return m_gamma_red; }
        fixed_point_16_dot_16_t* gamma_blue() const { return m_gamma_blue; }
        fixed_point_16_dot_16_t* gamma_green() const { return m_gamma_green; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_header_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/previous-versions/dd183376(v=vs.85) Source
     */

    class bitmap_info_extension_t : public kaitai::kstruct {

    public:

        bitmap_info_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_info_extension_t();

    private:
        compressions_t m_compression;
        bool n_compression;

    public:
        bool _is_null_compression() { compression(); return n_compression; };

    private:
        os2_compressions_t m_os2_compression;
        bool n_os2_compression;

    public:
        bool _is_null_os2_compression() { os2_compression(); return n_os2_compression; };

    private:
        uint32_t m_len_image;
        uint32_t m_x_resolution;
        uint32_t m_y_resolution;
        uint32_t m_num_colors_used;
        uint32_t m_num_colors_important;
        bmp_t* m__root;
        bmp_t::bitmap_header_t* m__parent;

    public:
        compressions_t compression() const { return m_compression; }
        os2_compressions_t os2_compression() const { return m_os2_compression; }

        /**
         * If biCompression is BI_JPEG or BI_PNG, indicates the size of the JPEG or PNG image buffer.
         * This may be set to zero for BI_RGB bitmaps.
         */
        uint32_t len_image() const { return m_len_image; }
        uint32_t x_resolution() const { return m_x_resolution; }
        uint32_t y_resolution() const { return m_y_resolution; }
        uint32_t num_colors_used() const { return m_num_colors_used; }
        uint32_t num_colors_important() const { return m_num_colors_important; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_header_t* _parent() const { return m__parent; }
    };

    class fixed_point_2_dot_30_t : public kaitai::kstruct {

    public:

        fixed_point_2_dot_30_t(kaitai::kstream* p__io, bmp_t::cie_xyz_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~fixed_point_2_dot_30_t();

    private:
        bool f_value;
        double m_value;

    public:
        double value();

    private:
        uint32_t m_raw;
        bmp_t* m__root;
        bmp_t::cie_xyz_t* m__parent;

    public:
        uint32_t raw() const { return m_raw; }
        bmp_t* _root() const { return m__root; }
        bmp_t::cie_xyz_t* _parent() const { return m__parent; }
    };

    /**
     * Replace with an opaque type if you care about the pixels. You can look at
     * an example of a JavaScript implementation:
     * <https://github.com/generalmimon/bmptool/blob/master/src/Bitmap.js>
     * 
     * There is a proposal for adding bitmap data type to Kaitai Struct:
     * <https://github.com/kaitai-io/kaitai_struct/issues/188>
     */

    class bitmap_t : public kaitai::kstruct {

    public:

        bitmap_t(kaitai::kstream* p__io, bmp_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_t();

    private:
        bmp_t* m__root;
        bmp_t* m__parent;

    public:
        bmp_t* _root() const { return m__root; }
        bmp_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapcoreheader Source
     * \sa https://www.fileformat.info/format/os2bmp/egff.htm#OS2BMP-DMYID.3.1 Source
     */

    class bitmap_header_t : public kaitai::kstruct {

    public:

        bitmap_header_t(uint32_t p_len_header, kaitai::kstream* p__io, bmp_t::bitmap_info_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_header_t();

    private:
        bool f_extends_bitmap_v4;
        bool m_extends_bitmap_v4;

    public:
        bool extends_bitmap_v4();

    private:
        bool f_extends_os2_2x_bitmap;
        bool m_extends_os2_2x_bitmap;

    public:
        bool extends_os2_2x_bitmap();

    private:
        bool f_uses_fixed_palette;
        bool m_uses_fixed_palette;

    public:
        bool uses_fixed_palette();

    private:
        bool f_extends_bitmap_info;
        bool m_extends_bitmap_info;

    public:
        bool extends_bitmap_info();

    private:
        bool f_image_height;
        int32_t m_image_height;

    public:
        int32_t image_height();

    private:
        bool f_is_core_header;
        bool m_is_core_header;

    public:
        bool is_core_header();

    private:
        bool f_extends_bitmap_v5;
        bool m_extends_bitmap_v5;

    public:
        bool extends_bitmap_v5();

    private:
        bool f_is_color_mask_here;
        bool m_is_color_mask_here;

    public:
        bool is_color_mask_here();

    private:
        bool f_bottom_up;
        bool m_bottom_up;

    public:
        bool bottom_up();

    private:
        uint32_t m_image_width;
        bool n_image_width;

    public:
        bool _is_null_image_width() { image_width(); return n_image_width; };

    private:
        int32_t m_image_height_raw;
        bool n_image_height_raw;

    public:
        bool _is_null_image_height_raw() { image_height_raw(); return n_image_height_raw; };

    private:
        uint16_t m_num_planes;
        uint16_t m_bits_per_pixel;
        bitmap_info_extension_t* m_bitmap_info_ext;
        bool n_bitmap_info_ext;

    public:
        bool _is_null_bitmap_info_ext() { bitmap_info_ext(); return n_bitmap_info_ext; };

    private:
        color_mask_t* m_color_mask;
        bool n_color_mask;

    public:
        bool _is_null_color_mask() { color_mask(); return n_color_mask; };

    private:
        os2_2x_bitmap_extension_t* m_os2_2x_bitmap_ext;
        bool n_os2_2x_bitmap_ext;

    public:
        bool _is_null_os2_2x_bitmap_ext() { os2_2x_bitmap_ext(); return n_os2_2x_bitmap_ext; };

    private:
        bitmap_v4_extension_t* m_bitmap_v4_ext;
        bool n_bitmap_v4_ext;

    public:
        bool _is_null_bitmap_v4_ext() { bitmap_v4_ext(); return n_bitmap_v4_ext; };

    private:
        bitmap_v5_extension_t* m_bitmap_v5_ext;
        bool n_bitmap_v5_ext;

    public:
        bool _is_null_bitmap_v5_ext() { bitmap_v5_ext(); return n_bitmap_v5_ext; };

    private:
        uint32_t m_len_header;
        bmp_t* m__root;
        bmp_t::bitmap_info_t* m__parent;

    public:

        /**
         * Image width, px
         */
        uint32_t image_width() const { return m_image_width; }

        /**
         * Image height, px (positive => bottom-up image, negative => top-down image)
         */
        int32_t image_height_raw() const { return m_image_height_raw; }

        /**
         * Number of planes for target device, must be 1
         */
        uint16_t num_planes() const { return m_num_planes; }

        /**
         * Number of bits per pixel that image buffer uses (1, 4, 8, 16, 24 or 32)
         */
        uint16_t bits_per_pixel() const { return m_bits_per_pixel; }
        bitmap_info_extension_t* bitmap_info_ext() const { return m_bitmap_info_ext; }
        color_mask_t* color_mask() const { return m_color_mask; }
        os2_2x_bitmap_extension_t* os2_2x_bitmap_ext() const { return m_os2_2x_bitmap_ext; }
        bitmap_v4_extension_t* bitmap_v4_ext() const { return m_bitmap_v4_ext; }
        bitmap_v5_extension_t* bitmap_v5_ext() const { return m_bitmap_v5_ext; }
        uint32_t len_header() const { return m_len_header; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_info_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://www.fileformat.info/format/os2bmp/egff.htm#OS2BMP-DMYID.3.2 Source
     */

    class os2_2x_bitmap_extension_t : public kaitai::kstruct {

    public:

        os2_2x_bitmap_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~os2_2x_bitmap_extension_t();

    private:
        uint16_t m_units;
        uint16_t m_reserved;
        uint16_t m_recording;
        os2_rendering_t m_rendering;
        uint32_t m_size1;
        uint32_t m_size2;
        uint32_t m_color_encoding;
        uint32_t m_identifier;
        bmp_t* m__root;
        bmp_t::bitmap_header_t* m__parent;

    public:
        uint16_t units() const { return m_units; }
        uint16_t reserved() const { return m_reserved; }

        /**
         * Specifies how the bitmap scan lines are stored.
         * The only valid value for this field is 0, indicating that the bitmap is
         * stored from left to right and from the bottom up.
         */
        uint16_t recording() const { return m_recording; }

        /**
         * Specifies the halftoning algorithm used on the bitmap data.
         */
        os2_rendering_t rendering() const { return m_rendering; }

        /**
         * rendering == os2_rendering::error_diffusion
         *   => error damping as a percentage in the range 0 through 100
         * rendering == os2_rendering::panda or rendering == os2_rendering::super_circle
         *   => X dimension of the pattern used in pixels
         */
        uint32_t size1() const { return m_size1; }

        /**
         * rendering == os2_rendering::error_diffusion
         *   => not used
         * rendering == os2_rendering::panda or rendering == os2_rendering::super_circle
         *   => Y dimension of the pattern used in pixels
         */
        uint32_t size2() const { return m_size2; }

        /**
         * Specifies the color model used to describe the bitmap data.
         * The only valid value is 0, indicating the RGB encoding scheme.
         */
        uint32_t color_encoding() const { return m_color_encoding; }

        /**
         * Application-specific value
         */
        uint32_t identifier() const { return m_identifier; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_header_t* _parent() const { return m__parent; }
    };

    class fixed_point_16_dot_16_t : public kaitai::kstruct {

    public:

        fixed_point_16_dot_16_t(kaitai::kstream* p__io, bmp_t::bitmap_v4_extension_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~fixed_point_16_dot_16_t();

    private:
        bool f_value;
        double m_value;

    public:
        double value();

    private:
        uint32_t m_raw;
        bmp_t* m__root;
        bmp_t::bitmap_v4_extension_t* m__parent;

    public:
        uint32_t raw() const { return m_raw; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_v4_extension_t* _parent() const { return m__parent; }
    };

    class color_table_t : public kaitai::kstruct {

    public:

        color_table_t(bool p_has_reserved_field, uint32_t p_num_colors, kaitai::kstream* p__io, bmp_t::bitmap_info_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~color_table_t();

    private:
        bool f_num_colors_present;
        int32_t m_num_colors_present;

    public:
        int32_t num_colors_present();

    private:
        std::vector<rgb_record_t*>* m_colors;
        bool m_has_reserved_field;
        uint32_t m_num_colors;
        bmp_t* m__root;
        bmp_t::bitmap_info_t* m__parent;

    public:
        std::vector<rgb_record_t*>* colors() const { return m_colors; }
        bool has_reserved_field() const { return m_has_reserved_field; }

        /**
         * If equal to 0, the pallete should contain as many colors as can fit into the pixel value
         * according to the `bits_per_pixel` field (if `bits_per_pixel` = 8, then the pixel can
         * represent 2 ** 8 = 256 values, so exactly 256 colors should be present). For more flexibility,
         * it reads as many colors as it can until EOS is reached (and the image data begin).
         */
        uint32_t num_colors() const { return m_num_colors; }
        bmp_t* _root() const { return m__root; }
        bmp_t::bitmap_info_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapfileheader Source
     */

    class file_header_t : public kaitai::kstruct {

    public:

        file_header_t(kaitai::kstream* p__io, bmp_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~file_header_t();

    private:
        std::string m_file_type;
        uint32_t m_len_file;
        uint16_t m_reserved1;
        uint16_t m_reserved2;
        int32_t m_ofs_bitmap;
        bmp_t* m__root;
        bmp_t* m__parent;

    public:
        std::string file_type() const { return m_file_type; }

        /**
         * not reliable, mostly ignored by BMP decoders
         */
        uint32_t len_file() const { return m_len_file; }
        uint16_t reserved1() const { return m_reserved1; }
        uint16_t reserved2() const { return m_reserved2; }

        /**
         * Offset to actual raw pixel data of the image
         */
        int32_t ofs_bitmap() const { return m_ofs_bitmap; }
        bmp_t* _root() const { return m__root; }
        bmp_t* _parent() const { return m__parent; }
    };

    /**
     * \sa https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapinfo Source
     */

    class bitmap_info_t : public kaitai::kstruct {

    public:

        bitmap_info_t(kaitai::kstream* p__io, bmp_t* p__parent = 0, bmp_t* p__root = 0);

    private:
        void _read();
        void _clean_up();

    public:
        ~bitmap_info_t();

    private:
        bool f_is_color_mask_given;
        bool m_is_color_mask_given;

    public:
        bool is_color_mask_given();

    private:
        bool f_color_mask_given;
        color_mask_t* m_color_mask_given;
        bool n_color_mask_given;

    public:
        bool _is_null_color_mask_given() { color_mask_given(); return n_color_mask_given; };

    private:

    public:
        color_mask_t* color_mask_given();

    private:
        bool f_color_mask_blue;
        uint32_t m_color_mask_blue;

    public:
        uint32_t color_mask_blue();

    private:
        bool f_color_mask_alpha;
        uint32_t m_color_mask_alpha;

    public:
        uint32_t color_mask_alpha();

    private:
        bool f_color_mask_green;
        int32_t m_color_mask_green;

    public:
        int32_t color_mask_green();

    private:
        bool f_is_color_mask_here;
        bool m_is_color_mask_here;

    public:
        bool is_color_mask_here();

    private:
        bool f_color_mask_red;
        int32_t m_color_mask_red;

    public:
        int32_t color_mask_red();

    private:
        uint32_t m_len_header;
        bitmap_header_t* m_header;
        color_mask_t* m_color_mask;
        bool n_color_mask;

    public:
        bool _is_null_color_mask() { color_mask(); return n_color_mask; };

    private:
        color_table_t* m_color_table;
        bool n_color_table;

    public:
        bool _is_null_color_table() { color_table(); return n_color_table; };

    private:
        bmp_t* m__root;
        bmp_t* m__parent;
        std::string m__raw_header;
        kaitai::kstream* m__io__raw_header;
        std::string m__raw_color_table;
        bool n__raw_color_table;

    public:
        bool _is_null__raw_color_table() { _raw_color_table(); return n__raw_color_table; };

    private:
        kaitai::kstream* m__io__raw_color_table;

    public:
        uint32_t len_header() const { return m_len_header; }
        bitmap_header_t* header() const { return m_header; }

        /**
         * Valid only for BITMAPINFOHEADER, in all headers extending it the masks are contained in the header itself.
         */
        color_mask_t* color_mask() const { return m_color_mask; }
        color_table_t* color_table() const { return m_color_table; }
        bmp_t* _root() const { return m__root; }
        bmp_t* _parent() const { return m__parent; }
        std::string _raw_header() const { return m__raw_header; }
        kaitai::kstream* _io__raw_header() const { return m__io__raw_header; }
        std::string _raw_color_table() const { return m__raw_color_table; }
        kaitai::kstream* _io__raw_color_table() const { return m__io__raw_color_table; }
    };

private:
    file_header_t* m_file_hdr;
    bitmap_info_t* m_dib_info;
    bitmap_t* m_bitmap;
    bmp_t* m__root;
    kaitai::kstruct* m__parent;
    std::string m__raw_dib_info;
    kaitai::kstream* m__io__raw_dib_info;
    std::string m__raw_bitmap;
    kaitai::kstream* m__io__raw_bitmap;

public:
    file_header_t* file_hdr() const { return m_file_hdr; }
    bitmap_info_t* dib_info() const { return m_dib_info; }
    bitmap_t* bitmap() const { return m_bitmap; }
    bmp_t* _root() const { return m__root; }
    kaitai::kstruct* _parent() const { return m__parent; }
    std::string _raw_dib_info() const { return m__raw_dib_info; }
    kaitai::kstream* _io__raw_dib_info() const { return m__io__raw_dib_info; }
    std::string _raw_bitmap() const { return m__raw_bitmap; }
    kaitai::kstream* _io__raw_bitmap() const { return m__io__raw_bitmap; }
};

#endif  // BMP_H_

// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild

#include "bmp.h"
#include "kaitai/exceptions.h"

bmp_t::bmp_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = this;
    m_file_hdr = 0;
    m_dib_info = 0;
    m__io__raw_dib_info = 0;
    m_bitmap = 0;
    m__io__raw_bitmap = 0;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::_read() {
    m_file_hdr = new file_header_t(m__io, this, m__root);
    m__raw_dib_info = m__io->read_bytes((file_hdr()->ofs_bitmap() - 14));
    m__io__raw_dib_info = new kaitai::kstream(m__raw_dib_info);
    m_dib_info = new bitmap_info_t(m__io__raw_dib_info, this, m__root);
    m__raw_bitmap = m__io->read_bytes_full();
    m__io__raw_bitmap = new kaitai::kstream(m__raw_bitmap);
    m_bitmap = new bitmap_t(m__io__raw_bitmap, this, m__root);
}

bmp_t::~bmp_t() {
    _clean_up();
}

void bmp_t::_clean_up() {
    if (m_file_hdr) {
        delete m_file_hdr; m_file_hdr = 0;
    }
    if (m__io__raw_dib_info) {
        delete m__io__raw_dib_info; m__io__raw_dib_info = 0;
    }
    if (m_dib_info) {
        delete m_dib_info; m_dib_info = 0;
    }
    if (m__io__raw_bitmap) {
        delete m__io__raw_bitmap; m__io__raw_bitmap = 0;
    }
    if (m_bitmap) {
        delete m_bitmap; m_bitmap = 0;
    }
}

bmp_t::cie_xyz_t::cie_xyz_t(kaitai::kstream* p__io, bmp_t::bitmap_v4_extension_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_x = 0;
    m_y = 0;
    m_z = 0;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::cie_xyz_t::_read() {
    m_x = new fixed_point_2_dot_30_t(m__io, this, m__root);
    m_y = new fixed_point_2_dot_30_t(m__io, this, m__root);
    m_z = new fixed_point_2_dot_30_t(m__io, this, m__root);
}

bmp_t::cie_xyz_t::~cie_xyz_t() {
    _clean_up();
}

void bmp_t::cie_xyz_t::_clean_up() {
    if (m_x) {
        delete m_x; m_x = 0;
    }
    if (m_y) {
        delete m_y; m_y = 0;
    }
    if (m_z) {
        delete m_z; m_z = 0;
    }
}

bmp_t::rgb_record_t::rgb_record_t(bool p_has_reserved_field, kaitai::kstream* p__io, bmp_t::color_table_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_has_reserved_field = p_has_reserved_field;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::rgb_record_t::_read() {
    m_blue = m__io->read_u1();
    m_green = m__io->read_u1();
    m_red = m__io->read_u1();
    n_reserved = true;
    if (has_reserved_field()) {
        n_reserved = false;
        m_reserved = m__io->read_u1();
    }
}

bmp_t::rgb_record_t::~rgb_record_t() {
    _clean_up();
}

void bmp_t::rgb_record_t::_clean_up() {
    if (!n_reserved) {
    }
}

bmp_t::bitmap_v5_extension_t::bitmap_v5_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    f_has_profile = false;
    f_profile_data = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_v5_extension_t::_read() {
    m_intent = static_cast<bmp_t::intent_t>(m__io->read_u4le());
    m_ofs_profile = m__io->read_u4le();
    m_len_profile = m__io->read_u4le();
    m_reserved = m__io->read_u4le();
}

bmp_t::bitmap_v5_extension_t::~bitmap_v5_extension_t() {
    _clean_up();
}

void bmp_t::bitmap_v5_extension_t::_clean_up() {
    if (f_profile_data && !n_profile_data) {
        if (m__io__raw_profile_data) {
            delete m__io__raw_profile_data; m__io__raw_profile_data = 0;
        }
        if (m_profile_data) {
            delete m_profile_data; m_profile_data = 0;
        }
    }
}

bool bmp_t::bitmap_v5_extension_t::has_profile() {
    if (f_has_profile)
        return m_has_profile;
    m_has_profile =  ((_parent()->bitmap_v4_ext()->color_space_type() == bmp_t::COLOR_SPACE_PROFILE_LINKED) || (_parent()->bitmap_v4_ext()->color_space_type() == bmp_t::COLOR_SPACE_PROFILE_EMBEDDED)) ;
    f_has_profile = true;
    return m_has_profile;
}

std::string bmp_t::bitmap_v5_extension_t::profile_data() {
    if (f_profile_data)
        return m_profile_data;
    n_profile_data = true;
    if (has_profile()) {
        n_profile_data = false;
        kaitai::kstream *io = _root()->_io();
        std::streampos _pos = io->pos();
        io->seek((14 + ofs_profile()));
        n_profile_data = true;
        {
            bool on = _parent()->bitmap_v4_ext()->color_space_type() == bmp_t::COLOR_SPACE_PROFILE_LINKED;
            if (on == true) {
                n_profile_data = false;
                m_profile_data = kaitai::kstream::bytes_to_str(kaitai::kstream::bytes_terminate(io->read_bytes(len_profile()), 0, false), std::string("windows-1252"));
            }
            else {
                m__raw_profile_data = io->read_bytes(len_profile());
            }
        }
        io->seek(_pos);
        f_profile_data = true;
    }
    return m_profile_data;
}

bmp_t::color_mask_t::color_mask_t(bool p_has_alpha_mask, kaitai::kstream* p__io, kaitai::kstruct* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_has_alpha_mask = p_has_alpha_mask;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::color_mask_t::_read() {
    m_red_mask = m__io->read_u4le();
    m_green_mask = m__io->read_u4le();
    m_blue_mask = m__io->read_u4le();
    n_alpha_mask = true;
    if (has_alpha_mask()) {
        n_alpha_mask = false;
        m_alpha_mask = m__io->read_u4le();
    }
}

bmp_t::color_mask_t::~color_mask_t() {
    _clean_up();
}

void bmp_t::color_mask_t::_clean_up() {
    if (!n_alpha_mask) {
    }
}

bmp_t::bitmap_v4_extension_t::bitmap_v4_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_endpoint_red = 0;
    m_endpoint_green = 0;
    m_endpoint_blue = 0;
    m_gamma_red = 0;
    m_gamma_blue = 0;
    m_gamma_green = 0;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_v4_extension_t::_read() {
    m_color_space_type = static_cast<bmp_t::color_space_t>(m__io->read_u4le());
    m_endpoint_red = new cie_xyz_t(m__io, this, m__root);
    m_endpoint_green = new cie_xyz_t(m__io, this, m__root);
    m_endpoint_blue = new cie_xyz_t(m__io, this, m__root);
    m_gamma_red = new fixed_point_16_dot_16_t(m__io, this, m__root);
    m_gamma_blue = new fixed_point_16_dot_16_t(m__io, this, m__root);
    m_gamma_green = new fixed_point_16_dot_16_t(m__io, this, m__root);
}

bmp_t::bitmap_v4_extension_t::~bitmap_v4_extension_t() {
    _clean_up();
}

void bmp_t::bitmap_v4_extension_t::_clean_up() {
    if (m_endpoint_red) {
        delete m_endpoint_red; m_endpoint_red = 0;
    }
    if (m_endpoint_green) {
        delete m_endpoint_green; m_endpoint_green = 0;
    }
    if (m_endpoint_blue) {
        delete m_endpoint_blue; m_endpoint_blue = 0;
    }
    if (m_gamma_red) {
        delete m_gamma_red; m_gamma_red = 0;
    }
    if (m_gamma_blue) {
        delete m_gamma_blue; m_gamma_blue = 0;
    }
    if (m_gamma_green) {
        delete m_gamma_green; m_gamma_green = 0;
    }
}

bmp_t::bitmap_info_extension_t::bitmap_info_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_info_extension_t::_read() {
    n_compression = true;
    if (!(_parent()->extends_os2_2x_bitmap())) {
        n_compression = false;
        m_compression = static_cast<bmp_t::compressions_t>(m__io->read_u4le());
    }
    n_os2_compression = true;
    if (_parent()->extends_os2_2x_bitmap()) {
        n_os2_compression = false;
        m_os2_compression = static_cast<bmp_t::os2_compressions_t>(m__io->read_u4le());
    }
    m_len_image = m__io->read_u4le();
    m_x_resolution = m__io->read_u4le();
    m_y_resolution = m__io->read_u4le();
    m_num_colors_used = m__io->read_u4le();
    m_num_colors_important = m__io->read_u4le();
}

bmp_t::bitmap_info_extension_t::~bitmap_info_extension_t() {
    _clean_up();
}

void bmp_t::bitmap_info_extension_t::_clean_up() {
    if (!n_compression) {
    }
    if (!n_os2_compression) {
    }
}

bmp_t::fixed_point_2_dot_30_t::fixed_point_2_dot_30_t(kaitai::kstream* p__io, bmp_t::cie_xyz_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    f_value = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::fixed_point_2_dot_30_t::_read() {
    m_raw = m__io->read_u4le();
}

bmp_t::fixed_point_2_dot_30_t::~fixed_point_2_dot_30_t() {
    _clean_up();
}

void bmp_t::fixed_point_2_dot_30_t::_clean_up() {
}

double bmp_t::fixed_point_2_dot_30_t::value() {
    if (f_value)
        return m_value;
    m_value = ((raw() + 0.0) / (1 << 30));
    f_value = true;
    return m_value;
}

bmp_t::bitmap_t::bitmap_t(kaitai::kstream* p__io, bmp_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_t::_read() {
}

bmp_t::bitmap_t::~bitmap_t() {
    _clean_up();
}

void bmp_t::bitmap_t::_clean_up() {
}

bmp_t::bitmap_header_t::bitmap_header_t(uint32_t p_len_header, kaitai::kstream* p__io, bmp_t::bitmap_info_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_len_header = p_len_header;
    m_bitmap_info_ext = 0;
    m_color_mask = 0;
    m_os2_2x_bitmap_ext = 0;
    m_bitmap_v4_ext = 0;
    m_bitmap_v5_ext = 0;
    f_extends_bitmap_v4 = false;
    f_extends_os2_2x_bitmap = false;
    f_uses_fixed_palette = false;
    f_extends_bitmap_info = false;
    f_image_height = false;
    f_is_core_header = false;
    f_extends_bitmap_v5 = false;
    f_is_color_mask_here = false;
    f_bottom_up = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_header_t::_read() {
    n_image_width = true;
    {
        bool on = is_core_header();
        if (on == true) {
            n_image_width = false;
            m_image_width = m__io->read_u2le();
        }
        else if (on == false) {
            n_image_width = false;
            m_image_width = m__io->read_u4le();
        }
    }
    n_image_height_raw = true;
    {
        bool on = is_core_header();
        if (on == true) {
            n_image_height_raw = false;
            m_image_height_raw = m__io->read_s2le();
        }
        else if (on == false) {
            n_image_height_raw = false;
            m_image_height_raw = m__io->read_s4le();
        }
    }
    m_num_planes = m__io->read_u2le();
    m_bits_per_pixel = m__io->read_u2le();
    n_bitmap_info_ext = true;
    if (extends_bitmap_info()) {
        n_bitmap_info_ext = false;
        m_bitmap_info_ext = new bitmap_info_extension_t(m__io, this, m__root);
    }
    n_color_mask = true;
    if (is_color_mask_here()) {
        n_color_mask = false;
        m_color_mask = new color_mask_t(len_header() != bmp_t::HEADER_TYPE_BITMAP_V2_INFO_HEADER, m__io, this, m__root);
    }
    n_os2_2x_bitmap_ext = true;
    if (extends_os2_2x_bitmap()) {
        n_os2_2x_bitmap_ext = false;
        m_os2_2x_bitmap_ext = new os2_2x_bitmap_extension_t(m__io, this, m__root);
    }
    n_bitmap_v4_ext = true;
    if (extends_bitmap_v4()) {
        n_bitmap_v4_ext = false;
        m_bitmap_v4_ext = new bitmap_v4_extension_t(m__io, this, m__root);
    }
    n_bitmap_v5_ext = true;
    if (extends_bitmap_v5()) {
        n_bitmap_v5_ext = false;
        m_bitmap_v5_ext = new bitmap_v5_extension_t(m__io, this, m__root);
    }
}

bmp_t::bitmap_header_t::~bitmap_header_t() {
    _clean_up();
}

void bmp_t::bitmap_header_t::_clean_up() {
    if (!n_image_width) {
    }
    if (!n_image_height_raw) {
    }
    if (!n_bitmap_info_ext) {
        if (m_bitmap_info_ext) {
            delete m_bitmap_info_ext; m_bitmap_info_ext = 0;
        }
    }
    if (!n_color_mask) {
        if (m_color_mask) {
            delete m_color_mask; m_color_mask = 0;
        }
    }
    if (!n_os2_2x_bitmap_ext) {
        if (m_os2_2x_bitmap_ext) {
            delete m_os2_2x_bitmap_ext; m_os2_2x_bitmap_ext = 0;
        }
    }
    if (!n_bitmap_v4_ext) {
        if (m_bitmap_v4_ext) {
            delete m_bitmap_v4_ext; m_bitmap_v4_ext = 0;
        }
    }
    if (!n_bitmap_v5_ext) {
        if (m_bitmap_v5_ext) {
            delete m_bitmap_v5_ext; m_bitmap_v5_ext = 0;
        }
    }
}

bool bmp_t::bitmap_header_t::extends_bitmap_v4() {
    if (f_extends_bitmap_v4)
        return m_extends_bitmap_v4;
    m_extends_bitmap_v4 = len_header() >= bmp_t::HEADER_TYPE_BITMAP_V4_HEADER;
    f_extends_bitmap_v4 = true;
    return m_extends_bitmap_v4;
}

bool bmp_t::bitmap_header_t::extends_os2_2x_bitmap() {
    if (f_extends_os2_2x_bitmap)
        return m_extends_os2_2x_bitmap;
    m_extends_os2_2x_bitmap = len_header() == bmp_t::HEADER_TYPE_OS2_2X_BITMAP_HEADER;
    f_extends_os2_2x_bitmap = true;
    return m_extends_os2_2x_bitmap;
}

bool bmp_t::bitmap_header_t::uses_fixed_palette() {
    if (f_uses_fixed_palette)
        return m_uses_fixed_palette;
    m_uses_fixed_palette =  ((!( ((bits_per_pixel() == 16) || (bits_per_pixel() == 24) || (bits_per_pixel() == 32)) )) && (!( ((extends_bitmap_info()) && (!(extends_os2_2x_bitmap())) && ( ((bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_JPEG) || (bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_PNG)) )) ))) ;
    f_uses_fixed_palette = true;
    return m_uses_fixed_palette;
}

bool bmp_t::bitmap_header_t::extends_bitmap_info() {
    if (f_extends_bitmap_info)
        return m_extends_bitmap_info;
    m_extends_bitmap_info = len_header() >= bmp_t::HEADER_TYPE_BITMAP_INFO_HEADER;
    f_extends_bitmap_info = true;
    return m_extends_bitmap_info;
}

int32_t bmp_t::bitmap_header_t::image_height() {
    if (f_image_height)
        return m_image_height;
    m_image_height = ((image_height_raw() < 0) ? (-(image_height_raw())) : (image_height_raw()));
    f_image_height = true;
    return m_image_height;
}

bool bmp_t::bitmap_header_t::is_core_header() {
    if (f_is_core_header)
        return m_is_core_header;
    m_is_core_header = len_header() == bmp_t::HEADER_TYPE_BITMAP_CORE_HEADER;
    f_is_core_header = true;
    return m_is_core_header;
}

bool bmp_t::bitmap_header_t::extends_bitmap_v5() {
    if (f_extends_bitmap_v5)
        return m_extends_bitmap_v5;
    m_extends_bitmap_v5 = len_header() >= bmp_t::HEADER_TYPE_BITMAP_V5_HEADER;
    f_extends_bitmap_v5 = true;
    return m_extends_bitmap_v5;
}

bool bmp_t::bitmap_header_t::is_color_mask_here() {
    if (f_is_color_mask_here)
        return m_is_color_mask_here;
    m_is_color_mask_here =  ((len_header() == bmp_t::HEADER_TYPE_BITMAP_V2_INFO_HEADER) || (len_header() == bmp_t::HEADER_TYPE_BITMAP_V3_INFO_HEADER) || (extends_bitmap_v4())) ;
    f_is_color_mask_here = true;
    return m_is_color_mask_here;
}

bool bmp_t::bitmap_header_t::bottom_up() {
    if (f_bottom_up)
        return m_bottom_up;
    m_bottom_up = image_height_raw() > 0;
    f_bottom_up = true;
    return m_bottom_up;
}

bmp_t::os2_2x_bitmap_extension_t::os2_2x_bitmap_extension_t(kaitai::kstream* p__io, bmp_t::bitmap_header_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::os2_2x_bitmap_extension_t::_read() {
    m_units = m__io->read_u2le();
    m_reserved = m__io->read_u2le();
    m_recording = m__io->read_u2le();
    m_rendering = static_cast<bmp_t::os2_rendering_t>(m__io->read_u2le());
    m_size1 = m__io->read_u4le();
    m_size2 = m__io->read_u4le();
    m_color_encoding = m__io->read_u4le();
    m_identifier = m__io->read_u4le();
}

bmp_t::os2_2x_bitmap_extension_t::~os2_2x_bitmap_extension_t() {
    _clean_up();
}

void bmp_t::os2_2x_bitmap_extension_t::_clean_up() {
}

bmp_t::fixed_point_16_dot_16_t::fixed_point_16_dot_16_t(kaitai::kstream* p__io, bmp_t::bitmap_v4_extension_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    f_value = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::fixed_point_16_dot_16_t::_read() {
    m_raw = m__io->read_u4le();
}

bmp_t::fixed_point_16_dot_16_t::~fixed_point_16_dot_16_t() {
    _clean_up();
}

void bmp_t::fixed_point_16_dot_16_t::_clean_up() {
}

double bmp_t::fixed_point_16_dot_16_t::value() {
    if (f_value)
        return m_value;
    m_value = ((raw() + 0.0) / (1 << 16));
    f_value = true;
    return m_value;
}

bmp_t::color_table_t::color_table_t(bool p_has_reserved_field, uint32_t p_num_colors, kaitai::kstream* p__io, bmp_t::bitmap_info_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_has_reserved_field = p_has_reserved_field;
    m_num_colors = p_num_colors;
    m_colors = 0;
    f_num_colors_present = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::color_table_t::_read() {
    m_colors = new std::vector<rgb_record_t*>();
    const int l_colors = (( ((num_colors() > 0) && (num_colors() < num_colors_present())) ) ? (num_colors()) : (num_colors_present()));
    for (int i = 0; i < l_colors; i++) {
        m_colors->push_back(new rgb_record_t(has_reserved_field(), m__io, this, m__root));
    }
}

bmp_t::color_table_t::~color_table_t() {
    _clean_up();
}

void bmp_t::color_table_t::_clean_up() {
    if (m_colors) {
        for (std::vector<rgb_record_t*>::iterator it = m_colors->begin(); it != m_colors->end(); ++it) {
            delete *it;
        }
        delete m_colors; m_colors = 0;
    }
}

int32_t bmp_t::color_table_t::num_colors_present() {
    if (f_num_colors_present)
        return m_num_colors_present;
    m_num_colors_present = (_io()->size() / ((has_reserved_field()) ? (4) : (3)));
    f_num_colors_present = true;
    return m_num_colors_present;
}

bmp_t::file_header_t::file_header_t(kaitai::kstream* p__io, bmp_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::file_header_t::_read() {
    m_file_type = m__io->read_bytes(2);
    if (!(file_type() == std::string("\x42\x4D", 2))) {
        throw kaitai::validation_not_equal_error<std::string>(std::string("\x42\x4D", 2), file_type(), _io(), std::string("/types/file_header/seq/0"));
    }
    m_len_file = m__io->read_u4le();
    m_reserved1 = m__io->read_u2le();
    m_reserved2 = m__io->read_u2le();
    m_ofs_bitmap = m__io->read_s4le();
}

bmp_t::file_header_t::~file_header_t() {
    _clean_up();
}

void bmp_t::file_header_t::_clean_up() {
}

bmp_t::bitmap_info_t::bitmap_info_t(kaitai::kstream* p__io, bmp_t* p__parent, bmp_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    m_header = 0;
    m__io__raw_header = 0;
    m_color_mask = 0;
    m_color_table = 0;
    m__io__raw_color_table = 0;
    f_is_color_mask_given = false;
    f_color_mask_given = false;
    f_color_mask_blue = false;
    f_color_mask_alpha = false;
    f_color_mask_green = false;
    f_is_color_mask_here = false;
    f_color_mask_red = false;

    try {
        _read();
    } catch(...) {
        _clean_up();
        throw;
    }
}

void bmp_t::bitmap_info_t::_read() {
    m_len_header = m__io->read_u4le();
    m__raw_header = m__io->read_bytes((len_header() - 4));
    m__io__raw_header = new kaitai::kstream(m__raw_header);
    m_header = new bitmap_header_t(len_header(), m__io__raw_header, this, m__root);
    n_color_mask = true;
    if (is_color_mask_here()) {
        n_color_mask = false;
        m_color_mask = new color_mask_t(header()->bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_ALPHA_BITFIELDS, m__io, this, m__root);
    }
    n_color_table = true;
    if (!(_io()->is_eof())) {
        n_color_table = false;
        m__raw_color_table = m__io->read_bytes_full();
        m__io__raw_color_table = new kaitai::kstream(m__raw_color_table);
        m_color_table = new color_table_t(!(header()->is_core_header()), ((header()->extends_bitmap_info()) ? (header()->bitmap_info_ext()->num_colors_used()) : (0)), m__io__raw_color_table, this, m__root);
    }
}

bmp_t::bitmap_info_t::~bitmap_info_t() {
    _clean_up();
}

void bmp_t::bitmap_info_t::_clean_up() {
    if (m__io__raw_header) {
        delete m__io__raw_header; m__io__raw_header = 0;
    }
    if (m_header) {
        delete m_header; m_header = 0;
    }
    if (!n_color_mask) {
        if (m_color_mask) {
            delete m_color_mask; m_color_mask = 0;
        }
    }
    if (!n_color_table) {
        if (m__io__raw_color_table) {
            delete m__io__raw_color_table; m__io__raw_color_table = 0;
        }
        if (m_color_table) {
            delete m_color_table; m_color_table = 0;
        }
    }
}

bool bmp_t::bitmap_info_t::is_color_mask_given() {
    if (f_is_color_mask_given)
        return m_is_color_mask_given;
    m_is_color_mask_given =  ((header()->extends_bitmap_info()) && ( ((header()->bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_BITFIELDS) || (header()->bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_ALPHA_BITFIELDS)) ) && ( ((is_color_mask_here()) || (header()->is_color_mask_here())) )) ;
    f_is_color_mask_given = true;
    return m_is_color_mask_given;
}

bmp_t::color_mask_t* bmp_t::bitmap_info_t::color_mask_given() {
    if (f_color_mask_given)
        return m_color_mask_given;
    n_color_mask_given = true;
    if (is_color_mask_given()) {
        n_color_mask_given = false;
        m_color_mask_given = ((is_color_mask_here()) ? (color_mask()) : (header()->color_mask()));
    }
    f_color_mask_given = true;
    return m_color_mask_given;
}

uint32_t bmp_t::bitmap_info_t::color_mask_blue() {
    if (f_color_mask_blue)
        return m_color_mask_blue;
    m_color_mask_blue = ((is_color_mask_given()) ? (color_mask_given()->blue_mask()) : (((header()->bits_per_pixel() == 16) ? (31) : ((( ((header()->bits_per_pixel() == 24) || (header()->bits_per_pixel() == 32)) ) ? (255) : (0))))));
    f_color_mask_blue = true;
    return m_color_mask_blue;
}

uint32_t bmp_t::bitmap_info_t::color_mask_alpha() {
    if (f_color_mask_alpha)
        return m_color_mask_alpha;
    m_color_mask_alpha = (( ((is_color_mask_given()) && (color_mask_given()->has_alpha_mask())) ) ? (color_mask_given()->alpha_mask()) : (0));
    f_color_mask_alpha = true;
    return m_color_mask_alpha;
}

int32_t bmp_t::bitmap_info_t::color_mask_green() {
    if (f_color_mask_green)
        return m_color_mask_green;
    m_color_mask_green = ((is_color_mask_given()) ? (color_mask_given()->green_mask()) : (((header()->bits_per_pixel() == 16) ? (992) : ((( ((header()->bits_per_pixel() == 24) || (header()->bits_per_pixel() == 32)) ) ? (65280) : (0))))));
    f_color_mask_green = true;
    return m_color_mask_green;
}

bool bmp_t::bitmap_info_t::is_color_mask_here() {
    if (f_is_color_mask_here)
        return m_is_color_mask_here;
    m_is_color_mask_here =  ((!(_io()->is_eof())) && (header()->len_header() == bmp_t::HEADER_TYPE_BITMAP_INFO_HEADER) && ( ((header()->bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_BITFIELDS) || (header()->bitmap_info_ext()->compression() == bmp_t::COMPRESSIONS_ALPHA_BITFIELDS)) )) ;
    f_is_color_mask_here = true;
    return m_is_color_mask_here;
}

int32_t bmp_t::bitmap_info_t::color_mask_red() {
    if (f_color_mask_red)
        return m_color_mask_red;
    m_color_mask_red = ((is_color_mask_given()) ? (color_mask_given()->red_mask()) : (((header()->bits_per_pixel() == 16) ? (31744) : ((( ((header()->bits_per_pixel() == 24) || (header()->bits_per_pixel() == 32)) ) ? (16711680) : (0))))));
    f_color_mask_red = true;
    return m_color_mask_red;
}