Legacy ImageMagick Discussions Archive

Code: Select all

     if ((m_type == PNG)) {
            // In case anything goes wrong, we just deliver the "bad" image.
            const unsigned char *sptr = reinterpret_cast<const unsigned char *>(outputblob.data());
            const unsigned char *send = sptr + outputblob.length();

            // This is our output buffer already allocated.
            unsigned char *dptr = reinterpret_cast<unsigned char *>(output_buffer);

            // Copy PNG header (0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A)
            std::memcpy(dptr, sptr, 8 );

            try {
                enum {
                    CNK_UNSORTED,
                    CNK_TEXT,
                    CNK_IMAGE,
                    CNK_IEND,

                    CNK_LAST // END marker, don't remove
                };

                typedef std::list<cpinfo> cplist_t;
                typedef cplist_t::const_iterator cplist_c;

                cplist_t chunks[4]; // 0 = Unsorted, 1 = Text, 2 = Image, 3 = IEND

                // Skip over the PNG header in both buffers
                const unsigned char *scur = sptr + 8; // 0x89 0x50 0x4E 0x47 0x0D 0x0A 0x1A 0x0A
                unsigned char *dcur = dptr + 8;

                // Scan chunks
                // Chunk format:
                // Offset Length Meaning
                // 0      4      Chunk length (big endian. This is length of "X" only!!)
                // 4      4      Chunk type (string)
                // 8      X      Chunk data
                // 8+X    4      CRC32 checksum

                // The PNG IHDR chunks must be the first chunk in the file, so copy him.
                bool header_processed = false;

                // This will also properly copy the IEND chunk
                while (send - scur) {
                    // This may of course scan beyond buffer's end.
                    // It's OK here - the blob IM delivered *is* valid PNG,
                    // no user-generated data or whatever.

                    // Fetch length, fill copy struct
                    const boost::uint32_t *lptr = reinterpret_cast<const boost::uint32_t *>(scur);
                    cpinfo cpi;
                    cpi.data = scur;
                    cpi.length = ntohl(*lptr);

                    // Fetch chunk type
                    scur += 4;

                    char ctype[5];
                    std::memcpy(ctype, scur, 4);
                    ctype[4] = '\0';

                    // The first chunk is IHDR, this _must_ be the first chunk so
                    // copy him to the output buffer immediately.
                    if (!header_processed) {
                        std::memcpy(dcur, cpi.data, cpi.length + 12);
                        dcur += (cpi.length + 12); // 4 length, 4 type, 4 crc32

                        header_processed = true;
                    } else {
                        // Non-IHDR chunk: Check chunk type
                        if ((std::strncmp(ctype, "tEXt", 4) == 0) || (std::strncmp(ctype, "zTXt", 4) == 0)
                                || (std::strncmp(ctype, "iTXt", 4) == 0)) {
                            // This is a text chunk 
                            chunks[CNK_TEXT].push_back(cpi);
                        } else if (std::strncmp(ctype, "IDAT", 4) == 0) {
                            // This is an image
                            chunks[CNK_IMAGE].push_back(cpi);
                        } else if (std::strncmp(ctype, "IEND", 4) == 0) {
                            // This is an IEND chunk
                            chunks[CNK_IEND].push_back(cpi);
                        } else {
                            // This is some other chunk
                            chunks[CNK_UNSORTED].push_back(cpi);
                        }
                    }

                    // Advance to next chunk. Add text length (4), payload length (X) and crc32 length (4)
                    scur += (cpi.length + 8 );
                }

Code: Select all

Magick::Image image("logo:");
image.density(Magick::Geometry("200"));
image.write("c:\\logo.png");

C:\>identify -verbose logo.png
Image: logo.png
  Format: PNG (Portable Network Graphics)
  Mime type: image/png
  Class: PseudoClass
  Geometry: 640x480+0+0
  Resolution: 200x200
  Print size: 3.2x2.4