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::en=
dl;
              set_length(static_cast<int32_t>(*tmp));
              std::cout << "Length value =3D> " <<=
 static_cast<int>(*tmp) << std::endl;
              break;

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

          case 2:
              {
              std::cout << "***DATA****" << std::endl;
              unsigned long int l =3D static_cast<unsigned long int>(=
get_length());
              std::cout << "buffer size should be " <<=
; get_length() << std::endl;
              int8_t * buffer =3D new int8_t[l];
              std::cout << "buffer element size is " <&l=
t; *buffer  << std::endl;
              std::cout << "buffer size is " << l  &l=
t;< 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  &l=
t;< std::endl;
              }
              set_data(buffer);
              }
              break;

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

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

      char * tmp2 =3D reinterpret_cast<char *>(tmp); //reading each b=
yte
      std::cout << "Sizeof Byte "  << sizeof(*tmp2) &=
lt;< std::endl;
      //std::cout << "Mark =3D=3D>>" << __LINE_=
_ << std::endl;
      for(int i=3D0; i<4; i++){
          std::cout << "Character " << i << &qu=
ot;::" << std::endl << "\t" << *tmp2>

<< 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); }

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