Indexing into a bitmap problem

Question

5.00/5 (1 vote)

See more:

I have an issue where I'm writing out a simple 8-bit grayscale bitmap as I read it from a stream.

The issue is this:

I'm going top to bottom left to right, and attempting to read the pixels out of the bitmap sequentially. I feel like this should work, but it doesn't. My data isn't in order.

However, when I explicitly force the stream to the correct position by seeking to this:

C++

bitmap_offset + (x + y * glyph.size.width)

It works.

Here's the thing I don't get - that should yield the same results as the sequential read because I am going top to bottom left to right (see the code in the other section). What am I missing? I don't want that extra seek in my code.

What I have tried:

C++

gfx_result vlw_font::draw(draw_callback draw_cb, const glyph& glyph, uint32_t bitmap_offset, void*state) const {
    if(draw_cb==nullptr || bitmap_offset<24+(glyph_count*28)) {
        return gfx_result::invalid_argument;
    }
    if(m_stream==nullptr || !m_stream->caps().read || !m_stream->caps().seek) {
        return gfx_result::invalid_state;
    }
    int y_adj = max_ascent-glyph.y_delta;
    seek_data(m_stream,bitmap_offset);
    for(int y = 0;y<glyph.size.height;++y) {
        for(int x = 0;x<glyph.size.width;++x) {
            uint8_t tmp;
            size_t s=1;
            // without the following two lines
            // the data is out of order
            uint32_t ofs = bitmap_offset + (x+y*glyph.size.width);
            seek_data(m_stream,ofs);

            read_data(m_stream,&tmp,&s);
            if(s!=1) return gfx_result::io_error;
            draw_cb(x+glyph.x_delta,y+y_adj,tmp,state);
        }
    }
    return gfx_result::success;
}

Posted 20-Aug-23 5:50am

honey the codewitch

Add a Solution

Comments

k5054 20-Aug-23 19:07pm

What is read_data() doing? Is it somehow causing the file offset pointer to be somewhere other than current + s when it returns?

honey the codewitch 21-Aug-23 1:07am

read_data simply reads from the stream at the last place it was seeked to, and advances the cursor by however many bytes were actually read.

Peter_in_2780 20-Aug-23 23:22pm

Don't know about your case, but in the past I (and a zillion others) have been bitten by end-of-line padding.
Particularly when the pixel size is not a divisor of the (padded) line length, things go down the gurgler very quickly.

honey the codewitch 21-Aug-23 1:08am

My bitmap code is such that there is no end of line padding, but yeah I know what you mean. I have to do some acrobatics on an e-paper panel driver i wrote due to that.

CPallini 21-Aug-23 2:53am

It looks read_data is not doing what you expect it should. Maybe it is doing more than you expect :-)

honey the codewitch 21-Aug-23 8:26am

yeah. It's a simple delegation used to just workaround the fact that my containing class can be const, but a stream read is not const because it changes the cursor position. So I forward to a static method, passing the stream, effectively circumventing the const restriction. It's sort of kludgy, but it's due to a const "polarity" mismatch introduced by the fact that the stream has a cursor. It's just two lines: *in_out_size=stm->read(buffer,*in_out_size); return gfx_result::success;

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Andre Oosthuizen · Accepted Answer · 2023-08-20T22:59:00

From what I could read (might be missing the ball completely) -

There shouldn't be a need for the extra seek operation, as you're already calculating the offset based on the pixel's position. It is possible that the issue might be related to the way your stream's internal state or buffer management is interacting with your sequential reads.

When you perform a read operation 'read_data' from the stream, it might consume a certain amount of data from your stream's internal buffer. This might cause the stream's internal position to become misaligned with your calculated offset 'ofs', leading to the out-of-order data.

By adding the extra seek operation, you are effectively resetting your stream's position to the expected offset, ensuring that the subsequent read operation starts from the correct position. While the extra seek might seem redundant, it could serve as a workaround for you to ensure proper alignment between your calculated offset and the stream's actual position. You can add a check if the calculated offset 'ofs' is different from your stream's current position. If the offset is the same as the current position, skip the seek operation and directly perform the read operation using 'read_data'. Not exactly what you wanted though but I hope it shed some light on your issue -

C++

gfx_result vlw_font::draw(draw_callback draw_cb, const glyph& glyph, uint32_t bitmap_offset, void* state) const {
    if (draw_cb == nullptr || bitmap_offset < 24 + (glyph_count * 28)) {
        return gfx_result::invalid_argument;
    }
    if (m_stream == nullptr || !m_stream->caps().read || !m_stream->caps().seek) {
        return gfx_result::invalid_state;
    }
    int y_adj = max_ascent - glyph.y_delta;

    for (int y = 0; y < glyph.size.height; ++y) {
        for (int x = 0; x < glyph.size.width; ++x) {
            uint8_t tmp;
            size_t s = 1;
            
            uint32_t ofs = bitmap_offset + (x + y * glyph.size.width);

            //Use seek_data only if the offset has changed to reset the misaligned position...
            if (ofs != m_stream->current_position()) {
                seek_data(m_stream, ofs);
            }

            read_data(m_stream, &tmp, &s);
            if (s != 1) return gfx_result::io_error;

            draw_cb(x + glyph.x_delta, y + y_adj, tmp, state);
        }
    }
    return gfx_result::success;
}