Here=E2=80=99s a solution you can apply to any uint32_t you read:

ceCode cpp">#include <iostream>
#include <cstdint>
#include <cassert>
#include <arpa/inet.h>
using namespace std;
int main()
{
    uint32_t x =3D 218103808span>; // How it comes from the PNG file (network order)=

    uint32_t y =3D ntohl(x);  =
// Convert to host order
    cout << x << endl;
    cout << y << endl;
    assert(y =3D=3D 13);
    return 0;
}

CL

Christopher League league-at-co=
ntrapunctus.net writes:

Ah=E2=80=A6 I can confirm the 218103808 number now. The number =
you=E2=80=99re seeing in the dump is in octal: the three highest-o=
rder bytes are 000(oct) and the low order byte is 015(oct) =3D=3D 8+5 =3D=
=3D 13(dec) =3D=3D D(hex).

So the full 32-bit number in hexadecimal is 0x0000000D.

Intel architecture stores those bytes in the order 0x0D, 0x00, 0x00, 0x0=
0.

This number, 0x0D000000 =3D=3D 218103808.

The D is in column 6 (counting from zero at the right), whose place-valu=
e is 16^6 =3D=3D 16777216, and 13*16777216 =3D=3D 218103808.

CL

Christopher League league-at-co=
ntrapunctus.net writes:

I can=E2=80=99t really confirm this based on the numbers you=E2=80=99ve =
given (218103808 isn=E2=80=99t how I think it would come out) but it sounds=
A LOT like an endianness issue. That is, the 4 bytes are stored big-endian=
in the file, but you=E2=80=99re operating on a system (Intel) that is litt=
le-endian. So if you read an entire uint32 at once, it doesn=E2=80=99t come=
out correctly. Reading one byte at a time, you can then swap the bytes int=
o the right order.

Also, that=E2=80=99s not a hex dump, right=E2=80=A6? is it octal? decima=
l?

CL

ruben safir ruben-at-mrbrklyn.com=
writes:

Hello

I=E2=80=99m having trouble with this imput of data from a PNG image. The=
specification says that =E2=80=9Cchunks=E2=80=9D have a 4 byte field that =
is the length of the attached data segment. I tried to read the length in f=
or a chunk that has a length of 13, which was confirmed in a hexdump

0000000 211 120 116 107 015 012 032 012 =E2=80=93>>000 000 000 015=
<<=E2=80=93 111 110 104 122 0000010 000 000 041 215 000 000 007 165 0=
10 006 000 000 001 206 055 074 0000020 336 000 000 000 004 147 101 115 101 =
000 000 261 217 013 374 141

I am storing the data in a uint32_t variable using the following code, b=
ut the value keeps showing up with a huge number 218103808 which happens to=
be the number that is evaluated by iostream for the value of the whole chu=
nk

done reading header

Sizeof Chunk 4 Raw Chunk Number 0: 218103808 LENGTHrong>* Length value =3D> 218103808 Sizeof Byte 1 Character 0:: ^-at- Byte 0=
:: 0 Character 1:: ^-at- Byte 1:: 0 Character 2:: ^-at- Byte 2:: 0 Character 3:: =
Byte 3:: 13

As yet, when I break it down by single bytes, it returns 0 0 0 13, which=
is correct. ddd seems to say the same thing, and I don=E2=80=99t know why.=
When evaluated as 4 bytes, you get this large number, but when you evaluat=
e them seperately, each byte, it comes out right.

The code snippet I=E2=80=99m using looks like this

in the .h file #ifndef PNGPRJ #define PNGPRJ #include names=
pace png_proj{ typedef uint32_t CHUNK;

In the .cpp file void Image::read_chunk() { char * cur =3D get_index(); =
CHUNK * tmp =3D reinterpret_cast(cur); std::cout << std::end=
l << =E2=80=9CSizeof Chunk=E2=80=9D << sizeof(tmp) <<=
std::endl; for(int j =3D 0; j<4; j++){ std::cout << =E2=80=9CRaw =
Chunk Number=E2=80=9D << j << =E2=80=9C:=E2=80=9D << >tmp << std::endl;

        switch ( j ) {
            case 0:
                std::cout << "***LENGTH****" << std::=
endl;
                set_length(static_cast<int32_t>(*tmp));
                std::cout << "Length value =3D> " <&l=
t; static_cast<int>(*tmp) << std::endl;
                break;

            case 1:
                std::cout << "***TYPE****" << std::en=
dl;
                set_type(static_cast<int32_t>(*tmp));
                break;

            case 2:
                {
                std::cout << "***DATA****" << std::en=
dl;
                unsigned long int l =3D static_cast<unsigned long int>=
;(get_length());
                std::cout << "buffer size should be " <&=
lt; get_length() << std::endl;
                int8_t * buffer =3D new int8_t[l];
                std::cout << "buffer element size is " <=
< *buffer  << std::endl;
                std::cout << "buffer size is " << l  =
<< std::endl;
                for(unsigned int k =3D 0; k < get_length(); k++){
                    buffer[k] =3D static_cast<int8_t>(tmp[k]);
                    std::cout << "data " << *buffer  =
<< std::endl;
                }
                set_data(buffer);
                }
                break;

            case 3:
                std::cout << "***CRC****" << std::end=
l;
                set_crc(static_cast<int32_t>(*tmp));
                break;

            default:
                std::cout << "***NOMANDSLAND****" << =
std::endl;
                break;
        }               /* -----  end switch  ----- */

        char * tmp2 =3D reinterpret_cast<char *>(tmp); //reading each=
 byte
        std::cout << "Sizeof Byte "  << sizeof(*tmp2)=
 << std::endl;
        //std::cout << "Mark =3D=3D>>" << __LIN=
E__ << std::endl;
        for(int i=3D0; i<4; i++){
            std::cout << "Character " << i << &=
quot;::" << std::endl << "\t" << *tmp2de>

<< std::endl; std::cout << =E2=80=9CByte=E2=80=9D << i=
<< =E2=80=9C::=E2=80=9D << std::endl << =E2=80=9C=E2=80=
=9D << static_cast(*tmp2) << std::endl; tmp2=
++; } std::cout< std::cout< tmp++;
cur =3D ( reinterpret_cast(tmp) ); } set_index(cur); }p>

I dug through libpng since this seems to not being doing what I expected=
. They seem to set it up as 4 byte array

void /* PRIVATE / png_push_read_chunk(png_structrp png_ptr, png_info=
rp info_ptr) { png_uint_32 chunk_name; #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORT=
ED int keep; / unknown handling method */ #endif

/* First we make sure we have enough data for the 4-byte chunk name * an=
d the 4-byte chunk length before proceeding with decoding the * chunk data.=
To fully decode each of these chunks, we also make * sure we have enough d=
ata in the buffer for the 4-byte CRC at the * end of every chunk (except ID=
AT, which is handled separately). */ if ((png_ptr->mode & PNG_HAVE_C=
HUNK_HEADER) =3D=3D 0) { png_byte chunk_length[4]; png_byte chunk_tag[4];p>

  PNG_PUSH_SAVE_BUFFER_IF_LT(8)
  png_push_fill_buffer(png_ptr, chunk_length, 4);
  png_ptr->push_length =3D png_get_uint_31(png_ptr, chunk_length);
  png_reset_crc(png_ptr);
  png_crc_read(png_ptr, chunk_tag, 4);
  png_ptr->chunk_name =3D PNG_CHUNK_FROM_STRING(chunk_tag);
  png_check_chunk_name(png_ptr, png_ptr->chunk_name);
  png_ptr->mode |=3D PNG_HAVE_CHUNK_HEADER;

}

I=E2=80=99m obviously not understanding something I=E2=80=99m evaluation=
here. So I=E2=80=99m wondering if anyone can shed light on this. http://ww=
w.nylxs.com/docs/grad_school/parallel/src/png/png_proj.h http://www.nylxs.c=
om/docs/grad_school/parallel/src/png/png_proj.cpp http://www.nylxs.com/docs=
/grad_school/parallel/src/png/main_png.cpp http://www.nylxs.com/docs/grad_s=
chool/parallel/src/png/makefile

ruben

let.me.in

Ruben _______________________________________________ Learn mailing list=
Learn-at-nylxs.com http://lists.mrbrklyn.com/mailman/listinfo/learn