{"id":135,"date":"2015-10-11T22:06:07","date_gmt":"2015-10-11T22:06:07","guid":{"rendered":"http:\/\/shajisoft.com\/shajisoft_wp\/?p=135"},"modified":"2016-01-07T19:49:15","modified_gmt":"2016-01-07T19:49:15","slug":"why-the-same-screenshot-is-saved-as-different-sized-pngs","status":"publish","type":"post","link":"https:\/\/shajisoft.com\/shajisoft_wp\/why-the-same-screenshot-is-saved-as-different-sized-pngs\/","title":{"rendered":"Why the Same Screenshot is Saved as PNG of Different Sizes by Different Tools"},"content":{"rendered":"

Different applications like Gimp and Windows Paint create PNG files of different sizes for the same screenshot. I am going to show how to parse PNG files by using Python and try to figure out the reason for the difference.
\n<\/p>\n

Introduction<\/h2>\n

PNG is one of the commonly used image formats on the Internet. I used to save screenshots as PNG files. Unlike normal photos, screenshots of software applications usually have less colors. Using PNG, we can easily get images with good qualities and small file sizes. What’s more, it’s an open source format. For these reasons, I prefer PNG to other formats when creating screenshots.<\/p>\n

To be honest, I hadn’t paid much attention to the actual sizes of PNG files generated by software tools until recently when I need to create some PNG files for my blog and web pages. I mainly use two software tools to create screenshots which are Gimp and Windows Paint. I assumed that these tools would generate PNG files of optimal sizes. Whereas, I noticed recently that Gimp and Windows Paint generate PNG of different sizes of the same screenshot. Although there are no options about PNG format in Windows Paint, it still creates smaller PNG files than Gimp with the highest compression level selected. Then I was curious about the difference. So I did some experiments. In this post, I am going to share something I have learned about PNG from the process.<\/p>\n

PNG format<\/h2>\n

Here, PNG refers to Portable Network Graphics. It’s a raster graphics file format. It was created as a replacement to GIF which uses a patented compression algorithm LZW. Please refer to the Wikipedia<\/a> for more details of PNG format.<\/p>\n

Basically a PNG file starts with 8-byte header followed by chunks. Each chunk consists of four parts:<\/p>\n

    \n
  1. Length of the chunk – 4 bytes<\/li>\n
  2. Chunk type – 4 bytes<\/li>\n
  3. Chunk data – (Length of the chunk) bytes<\/li>\n
  4. CRC – 4 bytes<\/li>\n<\/ol>\n

    That is, if the first four bytes of a chunk is 8192 as an integer, it means that the data of the chunk has 8192 bytes, and the full size of the chunk is 4+4+8192+4 = 8204 bytes.<\/p>\n

    The second four bytes of a chunk indicates the type of the chunk, which is the case sensitive chunk type in ASCII format. A valid PNG file must have at least the following four critical chunk types:<\/p>\n

      \n
    1. IHDR: Must be the first chunk. It contains the meta information about the image like width, height etc<\/li>\n
    2. PLTE or sRGB: List of colors or the standard sRGB colors depending on the type of PNG<\/li>\n
    3. IDAT: Image data<\/li>\n
    4. IEND: Marks the end of the image<\/li>\n<\/ol>\n

      A PNG file can contain multiple IDAT chunks. To decode a PNG file, all IDAT chunks in a PNG file will be concatenated and the combined IDAT data is decompressed to give the image.<\/p>\n

      The following is a screenshot of TotalCommander Lister showing a PNG file in Hex format. We can see the first 8-byte header followed by IHDR and sRGB chunks:<\/p>\n

      \"A<\/a>
      A PNG file shown in Hex<\/figcaption><\/figure>\n

      Parse PNG file using Python<\/h2>\n

      Firstly, let’s create a class to model chunks in a PNG file:<\/p>\n

      class Chunk(object):\r\n\r\n    '''Definition of a chunk contained in a PNG file '''\r\n\r\n    def __init__(self, buf):\r\n        '''TODO: to be defined1. '''\r\n        self.__length = 0\r\n        self.__type = 0\r\n        self.__data = []\r\n        self.__crc = 0\r\n        self.__size = 0     # The total size of the chunk in bytes\r\n\r\n        if buf:\r\n            self.load(buf)\r\n\r\n    def load(self, buf):\r\n        '''Load the chunk from the given buffer.\r\n\r\n        @param buf List of bytes read from the PNG file\r\n        @return: None\r\n\r\n        '''\r\n        length_buf = binascii.hexlify(buf[:4])\r\n        #self.__length = int(''.join(length_buf), 16)\r\n        self.__length = int(length_buf, 16)\r\n\r\n        fmt = '4c'\r\n        #self.__type = ''.join(struct.unpack(fmt, ''.join(buf[4:8])))\r\n        self.__type = buf[4:8].decode()\r\n\r\n        end_data = 8+self.__length\r\n        self.__data = buf[8:end_data]\r\n        \r\n        buf = buf[end_data:]\r\n        crc_bytes = binascii.hexlify(buf[:4])\r\n        #self.__crc = int(''.join(crc_bytes), 16)\r\n        self.__crc = int(crc_bytes, 16)\r\n\r\n        self.__size = 8 + self.__length + 4;\r\n\r\n    def totalSize(self):\r\n        '''TODO: Returns the total size of the chunk in bytes.\r\n        @return: TODO\r\n\r\n        '''\r\n        return self.__size\r\n\r\n    def type(self):\r\n        '''TODO: Docstring for type.\r\n        @return: TODO\r\n\r\n        '''\r\n        return self.__type\r\n\r\n    def data(self):\r\n        '''TODO: Docstring for data.\r\n        @return: TODO\r\n\r\n        '''\r\n        return self.__data\r\n\r\n    def length(self):\r\n        '''TODO: Docstring for length.\r\n        @return: TODO\r\n\r\n        '''\r\n        return self.__length<\/pre>\n
       <\/p>\n
      To decode a PNG file, firstly open the file, read the content into a buffer, then decode the header and chunks:<\/p>\n
       <\/p>\n
      class PNG(object):\r\n\r\n    '''class for a PNG file. '''\r\n\r\n    def __init__(self, file_path):\r\n        '''TODO: to be defined1. '''\r\n        self.__fileName = file_path\r\n        self.__file = None\r\n        self.__fobj = None\r\n        self.size = [0, 0]\r\n        self.__chunks = []  # List of chunks\r\n        self.__width = 0\r\n        self.__height = 0\r\n        self.__bitDepth = 0\r\n        self.__colorType = 0\r\n        self.__cmpMtd = 0\r\n        self.__fltMtd = 0\r\n        self.__itlMtd = 0\r\n        self.__totalIDAT = 0\r\n\r\n        if file_path:\r\n            self.readFile(file_path)\r\n            self.__file = file_path\r\n    \r\n    def loadHeader(self, buf):\r\n        '''TODO: Docstring for loadHeader.\r\n\r\n        @param buf Byte buffer read from the import file\r\n        @return: TODO\r\n\r\n        '''\r\n        pass\r\n\r\n    def readFile(self, file_path):\r\n        '''TODO: Docstring for readFile.\r\n\r\n        @param file_path Full path to the png file\r\n        @return: True if successful, False otherwise\r\n\r\n        '''\r\n        \r\n        if file_path is None and self.__file is None:\r\n          logger.info(\"File name is empty. Nothing to load!\")\r\n          return\r\n          \r\n        if file_path is not None:\r\n          self.__file = file_path\r\n        \r\n        # Open the file for reading\r\n        self.__fobj = open( self.__file, 'rb')\r\n\r\n        fsize = os.path.getsize( file_path )\r\n        # map the file into memory\r\n        fno = self.__fobj.fileno()\r\n        data = mmap.mmap( fno, fsize, access=mmap.ACCESS_READ )\r\n\r\n        fmt = '8c'\r\n        header = struct.unpack( fmt, data[:8] )\r\n\r\n        # Get the header information\r\n        #self.loadHeader() \r\n        #logger.debug(\"Header: %s\" %  header )\r\n        \r\n        #working buffer   \r\n        buf = data[8:]\r\n        ihdr = Chunk(buf)\r\n        self.parseIHDR(ihdr.data() )\r\n\r\n        chunk_size = ihdr.totalSize()\r\n        self.__chunks = [] \r\n        self.__chunks.append(ihdr)\r\n        while len(buf) > chunk_size:\r\n            buf = buf[chunk_size:]\r\n            ck = Chunk(buf)\r\n            chunk_size = ck.totalSize()\r\n            self.__chunks.append(ck)\r\n       \r\n        self.parseIDAT()\r\n\r\n\r\n        ### close the file\r\n        data.close()\r\n        self.__fobj.close() \r\n...\r\n<\/pre>\n
      A valid PNG file contains at least one IDAT chunk. IDAT chunks contain compressed image data, which is a rectangular pixel array. Each pixel consists of color information. There are mainly three types of pixels in PNG files:<\/p>\n
        \n
      1. Grayscale pixel. Minimum pixel size: 1 bit<\/li>\n
      2. Color-indexed pixel. Minimum pixel size: 1 bit<\/li>\n
      3. Truecolor pixel: Minimum pixel size: 24-bit<\/li>\n<\/ol>\n
        Optionally, each pixel can have transparence information which is 8-bit. Therefore, a truecolor pixel with transparence consists of 4 bytes.<\/p>\n
        Image data is organized from the top to bottom. Each row of the image data is packed from the left to the right to form a scanline. Each scanline always starts with a single byte indicating the filter type followed by the packed pixel array of the image. All scanlines are then compressed by using DEFLATE algorithm which is the same as in zlib. We can use zlib module in Python to decompress data in IDAT chunk as shown below:<\/p>\n
            def testCompress(self):\r\n        idat_data = b''\r\n        self.__totalIDAT = 0\r\n        for i in range(1, len(self.__chunks)):\r\n            if self.__chunks[i].type() == 'IDAT':\r\n                idat_data += self.__chunks[i].data() \r\n       img_data = zlib.decompress( idat_data ) \r\n       ...\r\n<\/pre>\n
         <\/p>\n
        Please refer to zlib RFC page<\/a> for more details of the ZLIB compress data format specification. Basically zlib compressed data always has two bytes in the beginning to indicate compression information. For example, the first two bytes of zlib compressed data would appear to be “78 da” in hexadecimal. From these two bytes, we can guess some parameters used in DEFLATE algorithm. But can only get possible values for some parameters like compression level, because different compression level may result in the same header values in the compressed data. In order to figure out the actual compression parameters, we can use a try and error method to test the combination of parameters with commonly used values in Python.<\/p>\n
        There is already a Python module to parse PNG file. But because I want to test different data compression parameters, I wrote a Python script for the purpose. The complete Python script file can be downloaded from here<\/a>. The downloaded Python script, sspng.py, works with Python 2.7 and 3.4. It accepts one argument as the path to a png file, dumps the image mata information, and tries to figure out the compression parameters used to create the PNG file. If failed, it prints the actual IDAT sizes if using the compression parameters used in the test.<\/p>\n
        Exampels<\/h2>\n
        Let’s take a screenshot of TotalCommander on Windows 10 x64 as an example, which is shown below.<\/p>\n
        \"Screenshot<\/a>
        Screenshot of TotalCommander 8.52a on Windows 10<\/figcaption><\/figure>\n
        To take the screenshot, bring TotalCommander to the front on the desktop, press Alt-PrtScrn. It will copy the screenshot of TotalCommander to the clipboard. Then paste the image in applications which we want to use to edit and save the screenshot. Here, I am going to use Gimp v2.9 development version and the default Windows Paint. When saving the screenshot as a PNG in these two applications, there is no option to select in Paint regarding PNG file, whereas there are options including the compression level in Gimp to select. Take the default options in Gimp which means to use the highest compression level 9. The generated file sizes are shown below:<\/p>\n