Reading pixels array after reader

[danielt3]

I'm trying to write a pattern file for a BMP I have to process somewhere else and to learn the pattern language in general. So I wrote the following:

#include <std/mem.pat>
#include <std/io.pat>
#pragma pattern_limit 50000


enum CompressionMethod: u32 {
    BI_RGB,
    BI_RLE8,
    BI_RLE4,
    BI_BITFIELDS,
    BI_JPEG,
    BI_PNG,
    BI_ALPHABITFIELDS,
    BI_CYMK = 11,
    BI_CYMKRLE8,
    BI_CYMKRLE4
};

struct BmpInfoHeader {
    u32 dibHeaderSize;
    s32 widthInPixels;
    s32 heightInPixels;
    u16 numberOfColorPlanes;
    u16 bitsPerPixel;
    CompressionMethod compressionMethod;
    u32 rawBitmapDataSize;
    s32 hResolution;
    s32 vResolution;
    u32 nColorsInPallete;
    u32 nImportantColorsUsed;
};

struct BmpHeader {
    char magic[2];
    u32 fileSizeInBytes;
    u16 reserved1;
    u16 reserved2;
    u32 offsetToPixelArray;
};

struct Pixel {
    u8 blue;
    u8 green;
    u8 red;
};

fn GetNumberOfPixels( BmpInfoHeader infoheader ) {
    u64 nPixels = (infoheader.widthInPixels)*(infoheader.heightInPixels);
    std::print("nPixels = {}", nPixels);
    return nPixels;
};


struct Bmp {
    BmpHeader header;
    BmpInfoHeader infoHeader;    
    Pixel pixels[while($ < (std::mem::size() - header.offsetToPixelArray))];  
};

Bmp bmp @ 0x00;
GetNumberOfPixels(bmp.infoHeader);

When it runs it returns the following:

E: error[E0007]: Limit error.
E: Pattern count exceeded set limit of '50000'.
E: hint: If this is intended, try increasing the limit using '#pragma pattern_limit <new_limit>'.
I: Evaluation took 0.200246s

According to my calculations, this file has 44944 pixels which means that there will be an array of 44944 Pixel objects stored. Doesn't seem to be THAT MUCH.

I'm aware of the following answer: #334. I got the trick of reading a pattern until the end of the array from there. In my case, it is possible to calculate upfront how many pixels will be read, but I couldn't get it working either. I also know that there is already a BMP pattern to be loaded with the default install of the program but it loads an array of raw bytes not grouped pixels.

I also tried the following alternative:

struct Bmp {
    BmpHeader header;
    BmpInfoHeader infoHeader;    
    Pixel pixels[std::mem::size() - $];  
};

But it returns the following:

E: error[E0007]: Limit error.
E:   --> <Source Code>:57:38
E: 57 |     Pixel pixels[std::mem::size() - $];  
E:                                           ^
E:                                           Array grew past set limit of 65536
E: 
E: hint: If this is intended, try increasing the limit using '#pragma

Could you please help me understand what I'm doing wrong?

I'm using imhex-1.30.1-Windows-Portable-NoGPU-x86_64.

Thank you.

[jumanji144]

In this case, using the [[static]] attribute on Pixel will reduce the size downwards, because its size never changes. Pattern Language always assumes that all patterns are dynamic except given explicitly. If a pattern is static, in an array, instead of creating a copy for each element, it will just move the parent element to parse each one.

[danielt3]

You mean like this:

struct Pixel {
    u8 blue;
    u8 green;
    u8 red;
} [[static]];

struct Bmp {
    BmpHeader header;
    BmpInfoHeader infoHeader;    
    Pixel pixels[std::mem::size() - $];  
};

Didn't seem to help much. It returned:

E: error[E0004]: Type error.
E:   --> <Source Code>:57:38
E: 57 |     Pixel pixels[std::mem::size() - $];  
E:                                           ^
E:                                           Array expanded past end of the data.
E: 
E: 

[jumanji144]

Yes but that isn't the fault of the pattern size array, what you need to do is divide by sizeof(Pixel) as you are reading 3 bytes per entry, and you are just giving it the size in bytes from now to the end of the file

[danielt3]

Of course! My bad.

[danielt3]

The final pattern file is this one:

#include <std/mem.pat>
#include <std/io.pat>
#pragma pattern_limit 65536


enum CompressionMethod: u32 {
    BI_RGB,
    BI_RLE8,
    BI_RLE4,
    BI_BITFIELDS,
    BI_JPEG,
    BI_PNG,
    BI_ALPHABITFIELDS,
    BI_CYMK = 11,
    BI_CYMKRLE8,
    BI_CYMKRLE4
};

struct BmpInfoHeader {
    u32 dibHeaderSize;
    s32 widthInPixels;
    s32 heightInPixels;
    u16 numberOfColorPlanes;
    u16 bitsPerPixel;
    CompressionMethod compressionMethod;
    u32 rawBitmapDataSize;
    s32 hResolution;
    s32 vResolution;
    u32 nColorsInPallete;
    u32 nImportantColorsUsed;
} [[static]];

struct BmpHeader {
    char magic[2];
    u32 fileSizeInBytes;
    u16 reserved1;
    u16 reserved2;
    u32 offsetToPixelArray;
} [[static]];

struct Pixel3 {
    u8 blue [[color("0000FF")]];
    u8 green [[color("00FF00")]];
    u8 red [[color("FF0000")]];
} [[static]];

struct Pixel4 {
    u8 blue [[color("0000FF")]];
    u8 green [[color("00FF00")]];
    u8 red [[color("FF0000")]];
    u8 reserved [[color("777777")]];
} [[static]];


fn GetNumberOfPixels( BmpInfoHeader infoheader ) {
    u64 nPixels = (infoheader.widthInPixels)*(infoheader.heightInPixels);
    std::print("nPixels = {}", nPixels);
    return nPixels;
};

struct Bmp {
    BmpHeader header;
    BmpInfoHeader infoHeader; 
    if( infoHeader.bitsPerPixel == 32 ) {
        Pixel4 pixels[(std::mem::size() - $)/sizeof(Pixel4)];
    } else if (  infoHeader.bitsPerPixel == 24 ) {
        Pixel3 pixels[(std::mem::size() - $)/sizeof(Pixel3)];
    }      
};

Bmp bmp @ 0x00;
GetNumberOfPixels(bmp.infoHeader);

[jumanji144]

You might want to look at the Official BMP Pattern if you want to, if you want to see how we did it. But good job 👍

[danielt3]

I already looked at it and learned a trick or two about to properly build this.

Thank you!