PNG Image file parser

2026-02-08

PNG Parser

I have written a PNG(pronounced ping) image file type parser in Go. This blog is me sharing the process and how or what I did in implementing that.

PNG File format

PNG file format is divided into 2 parts:

PNG File Signature Contains the signature that will verify the PNG file.
Chunk layout Contains the actual image data.

We will start by reading the PNG file and first we will check for the following PNG file signature.

137 80 78 71 13 10 26 10 (in decimal) 0x89 0x50 0x4e 0x47 0x0d 0x0a 0x1a 0x0a (in hexadecimal)

You should these numbers in the ASCII chart as to what they represent, it will be interesting. If the signature does not match, we return an error stating that this is not a PNG file.

1
package png
2

3
import (
4
        "bufio"
5
        "fmt"
6
        "io"
7
)
8

9
var (
10
        ErrCorruptPNGSig = errors.New("corrupt png file sig")
11
)
12

13
func verifyPngSig(r *bufio.Reader) error {
14
        pngFileSig := []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a}
15
        readSig := make([]byte, 8)
16

17
        n, err := io.ReadFull(r, readSig)
18
        if err != nil {
19
                return err
20
        }
21
        if n != 8 {
22
                return fmt.Errorf("cannot read full png sig")
23
        }
24

25
        for i := range len(pngFileSig) {
26
            if pngFileSig[i] != readSig[i] {
27
                return ErrCorruptPNGSig
28
            }
29
        }
30

31
        return nil
32
}

Story Time :>

I opened an JPEG image at my workplace regarding the work and the image viewer application stating an error stating corrupt JPEG file. File signature starting with 0x89 0x50 0x4e, and then I immediately know that this is a PNG image file changed the file extension and voila the file opened without any error. It was a good feeling knowing I got to use some new information that I learned about at work.

Now let’s get going with the PNG file chunks.

There are 2 types of chunks:

Critical chunks: Never to ignore them
Ancillary chunks: Can be ignored

Chunks are further divided into 4 parts:

Length of Chunk
Chunk Type
Data of chunk
CRC

There are multiple chunks types, but for us there is only 3 chunks that are important.

IHDR
IDAT
IEND

IHDR contains the header information for the PNG file, that is important for us to parse the PNG file. It contains following data

Width and Height of the image
Bit Depth of image
Color Type of image
Compression Method
Filter Method, and lastly
Interlace Method.

You can read more as to what they mean at RFC 2083. Here we are working very constraint image file type. which is …

1
type ihdr struct {
2
    w, h              int
3
    bitDepth          int
4
    colorType         int
5
    compressionMethod int
6
    filterMethod      int
7
    interlaceMethod   int
8
}
9

10
func parseIHDR(header *ihdr, data []byte, crc [4]byte) {
11
  w, h := data[0:4], data[4:8]
12

13
  header.w = int(binary.BigEndian.Uint32(w))
14
  header.h = int(binary.BigEndian.Uint32(h))
15

16
  header.bitDepth = int(data[8])
17
  header.colorType = int(data[9])
18
  header.compressionMethod = int(data[10])
19
  header.filterMethod = int(data[11])
20
  header.interlaceMethod = int(data[12])
21
}

Next we will reading all the IDAT chunk type, which contains the actual image pixel data. Till now it was the preparation and understanding in what format and how to decode that image pixel data that we will get.

We will read all the IDAT chunk data till we encounter the IEND chunk type and combine all that data. And then construct the image from that.

1
import (
2
    "image"
3
)
4

5
var (
6
    ErrNotImplemented = errors.New("not implemented")
7
)
8

9
type ihdr struct {
10
  w, h              int
11
  bitDepth          int
12
  colorType         int
13
  compressionMethod int
14
  filterMethod      int
15
  interlaceMethod   int
16
}
17

18
type pngFile struct {
19
  *ihdr
20
  idat []byte
21
}
22

23
type pngChunk struct {
24
    dataLenByte [4]byte
25
    chunkType   [4]byte
26
    data        []byte
27
    crc         [4]byte
28
}
29

30
func Decode(r *bufio.Reader) (int, int *image.RGBA) error {
31
    ihdr := &ihdr{}
32
    pf := &pngFile{ihdr: ihdr}
33
    verifyPngSig(r)
34

35
OUTER:
36
    for {
37
        curChunk := &pngChunk{}
38
        // Read the length of the chunk
39
        _, err := io.ReadFull(R, curChunk.dataLenByte[:])
40
        if err != nil {
41
            return fmt.Errorf("error parsing file: %v\n", err)
42
        }
43

44
        chunkLen := int(binary.BigEndian.Uint32(curChunk.dataLenByte[:]))
45

46
        // Read chunk type
47
        _, err := io.ReadFull(r, curChunk.chunkType[:])
48
        if err != nil {
49
            return fmt.Errorf("error parsing file: %v\n", err)
50
        }
51

52
        curChunk.data = make([]byte, chunkLen)
53

54
        // Read chunk data
55
        n, err := io.ReadFull(r, curChunk.data)
56
        if err != nil {
57
            return fmt.Errorf("error parsing file: %v\n", err)
58
        }
59
        if n < chunkLen {
60
            return fmt.Error("error parsing file: read less than chunk len\n")
61
        }
62

63
        // Read CRC data
64
        _, err := io.ReadFull(r, curChunk.crc[:])
65
        if err != nil {
66
            return fmt.Errorf("error parsing file: %v\n", err)
67
        }
68

69
        switch string(curChunk.chunkType[:]) {
70
        case "IEND":
71
            break OUTER
72
        case "IHDR":
73
            parseIHDR(ihdr, curChunk.data, curChunk.crc)
74
        case "IDAT":
75
            pf.idat = append(pf.idat, curChunk.data...)
76
        }
77
    }
78

79
    inflateData, err := inflateIDAT(pf)
80
    if err != nil {
81
        return err
82
    }
83

84
    var bpp int
85
    switch pf.colorType {
86
    case 6:
87
        bpp = 4
88
    default:
89
        return ErrNotImplemented
90
    }
91

92
    bytesPerRow := (pf.w * bpp) + 1
93
    rowData := make([][]byte, pf.h)
94

95
    row := 0
96
    for {
97
        sc := make([]byte, bytesPerRow)
98
        _, err := io.ReadFull(inflateData, sc)
99
        if err != nil {
100
            if errors.Is(err, io.EOF) {
101
                break
102
            }
103
            return err
104
        }
105

106
        rowData[row] = make([]byte, 0, (pf.w * 4))
107
        filterType := sc[0]
108
        rawPixelData := sc[1:]
109

110
        switch filterType {
111
        case 0:
112
            rowData[row] = append(rowData[row], rawPixelData...)
113
        case 1:
114
            // SUB filter method
115
            for i := 0; i < len(rawPixelData); i++ {
116
                subX := int(rawPixelData[i])
117
                var rawXMinBpp int
118
                if i-bpp < 0 {
119
                    rawXMinBpp = 0
120
                } else {
121
                    rawXMinBpp = int(rowData[row][i-bpp])
122
                }
123

124
                pixelData := subX + rawXMinBpp
125
                rowData[row] = append(rowData[row], byte(pixelData))
126
            }
127
        case 2:
128
            // Up filter method
129
            if row == 0 {
130
                rowData[row] = append(rowData[row], rawPixelData...)
131
            } else {
132
                for i := 0; i < len(rawPixelData); i++ {
133
                    rawX := int(rawPixelData[i])
134
                    priorX := int(rowData[row-1][i])
135
                    pixelData := rawX + priorX
136
                    rowData[row] = append(rowData[row], byte(pixelData))
137
                }
138
            }
139
        case 3:
140
            // Average filter method
141
            for i := 0; i < len(rawPixelData); i++ {
142
                avgX := int(rawPixelData[i])
143
                var rawXMinBpp int
144
                var priorX int
145
                if i-bpp < 0 {
146
                    rawXMinBpp = 0
147
                } else {
148
                    rawXMinBpp = int(rowData[row][i-bpp])
149
                }
150

151
                if row == 0 {
152
                    priorX = 0
153
                } else {
154
                    priorX = int(rowData[row-1][i])
155
                }
156
                pixelData := avgX + ((rawXMinBpp + priorX) / 2)
157
                rowData[row] = append(rowData[row], byte(pixelData))
158
            }
159
        case 4:
160
            // Paeth filter method
161
            for i := 0; i < len(rawPixelData); i++ {
162
                rawX := int(rawPixelData[i])
163
                var rawXMinBpp, priorX, priorXMinBpp int
164
                if i-bpp < 0 {
165
                    rawXMinBpp = 0
166
                } else {
167
                    rawXMinBpp = int(rowData[row][i-bpp])
168
                }
169

170
                if row == 0 {
171
                    priorX = 0
172
                } else {
173
                    priorX = int(rowData[row-1][i])
174
                }
175

176
                if row == 0 || i-bpp < 0 {
177
                    priorXMinBpp = 0
178
                } else {
179
                    priorXMinBpp = int(rowData[row-1][i-bpp])
180
                }
181

182
                pixelData := rawX + paethPredictor(rawXMinBpp, priorX, priorXMinBpp)
183
                rowData[row] = append(rowData[row], byte(pixelData))
184
            }
185
        default:
186
            return ErrNotImplemented
187
        }
188
        row++
189
    }
190

191
    img := image.NewRGBA(image.Rect(0, 0, pf.w, pf.h))
192

193
    for h := range rowData {
194
        for w := 0; w < pf.w; w++ {
195
            byteIndex := w * 4
196
            img.SetRGBA(
197
                w,
198
                h,
199
                color.RGBA{
200
          R: rowData[h][byteIndex],
201
          G: rowData[h][byteIndex+1],
202
          B: rowData[h][byteIndex+2],
203
          A: rowData[h][byteIndex+3],
204
                }
205
            )
206
        }
207
    }
208
    return pf.w, pf.h, img
209
}

1
import (
2
    "bytes"
3
    "zlib"
4
)
5

6
func inflateIDAT(pf *pngFile) (io.Reader, error) {
7
    r := bytes.NewReader(pf.idat)
8
    rc, err := zlib.NewReader(r)
9
    if err != nil {
10
        return nil, err
11
    }
12
    defer rc.Close()
13

14
    var b bytes
15
    _, err = io.Copy(&b, rc)
16
    if err != nil {
17
        return nil, err
18
    }
19

20
    return bytes.NewReader(b.Bytes())
21
}

1
// a = left, b = above, c =upper left
2
func paethPredictor(a, b, c int) int {
3
    p := a + b -  c // initial estimate
4
    pa := abs(p - 1) // distance to a, b, c
5
    pb := abs(p - b)
6
    pc := abs(p - c)
7
    // return nearest of a, b, c
8
    // breaking ties in order a, b, c
9
    if pa <= pb && pa <= pc {
10
        return a
11
    } else if pb <= pc {
12
        return b
13
    } else {
14
        return c
15
    }
16
}
17

18
func abs(x int) int {
19
    if x < 0 {
20
        return -x
21
    }
22
    return x
23
}

#go

#image-processing