1 files changed, 158 insertions, 0 deletions

diff --git a/image/jpeg/quality.go b/image/jpeg/quality.go
new file mode 100644
index 0000000..674f0b8
--- /dev/null
+++ b/image/jpeg/quality.go
@@ -0,0 +1,158 @@
+package jpeg
+
+import (
+        "fmt"
+        "io"
+)
+
+var defaultTables = [][]int{
+        { // Luminance
+                16, 11, 12, 14, 12, 10, 16, 14,
+                13, 14, 18, 17, 16, 19, 24, 40,
+                26, 24, 22, 22, 24, 49, 35, 37,
+                29, 40, 58, 51, 61, 60, 57, 51,
+                56, 55, 64, 72, 92, 78, 64, 68,
+                87, 69, 55, 56, 80, 109, 81, 87,
+                95, 98, 103, 104, 103, 62, 77, 113,
+                121, 112, 100, 120, 92, 101, 103, 99,
+        },
+        { // Chrominance
+                17, 18, 18, 24, 21, 24, 47, 26,
+                26, 47, 99, 66, 56, 66, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+                99, 99, 99, 99, 99, 99, 99, 99,
+        },
+}
+
+func read2Bytes(r io.Reader) ([]byte, error) {
+        b := make([]byte, 2)
+        if _, err := r.Read(b); err != nil {
+                return nil, err
+        }
+        return b, nil
+}
+
+// ReadJPEGQuality returns the JPEG quality estimate.
+//
+// Cleaned up version of github.com/liut/jpegquality
+func ReadJPEGQuality(r io.ReadSeeker) (int, error) {
+        sign, err := read2Bytes(r)
+        if err != nil {
+                return 0, err
+        }
+
+        if sign[0] != 0xff && sign[1] != 0xd8 {
+                return 0, fmt.Errorf("invalid jpeg header")
+        }
+
+        for {
+                mark, err := read2Bytes(r)
+                if err != nil {
+                        return 0, err
+                }
+
+                if mark[0] != 0xff || mark[1] == 0xff || mark[1] == 0x00 {
+                        // Would also be valid to just keep re-reading to find the marker
+                        return 0, fmt.Errorf("invalid marker")
+                }
+
+                marker := int(mark[0])<<8 + int(mark[1])
+                if marker == 0 {
+                        return 0, fmt.Errorf("invalid jpeg header")
+                }
+
+                sign, err := read2Bytes(r)
+                if err != nil {
+                        return 0, err
+                }
+
+                length := int(sign[0])<<8 + int(sign[1]) - 2
+                if length < 0 {
+                        return 0, fmt.Errorf("short segment read")
+                }
+
+                if (marker & 0xff) != 0xdb { // not a quantization table
+                        if _, err := r.Seek(int64(length), 1); err != nil {
+                                return 0, err
+                        }
+                        continue
+                }
+
+                if length%65 != 0 {
+                        return 0, fmt.Errorf("wrong size for quantization table")
+                }
+
+                tabuf := make([]byte, length)
+                n, err := r.Read(tabuf)
+                if err != nil {
+                        return 0, err
+                }
+                tabuf = tabuf[0:n]
+
+                allones := 1
+
+                var reftable []int
+                var cumsf, cumsf2 float64
+
+                for a := 0; a < n; {
+                        tableindex := int(tabuf[a] & 0x0f)
+                        a++
+
+                        if tableindex < 2 {
+                                reftable = defaultTables[tableindex]
+                        }
+
+                        // Read in the table, compute statistics relative to reference table
+                        if a+64 > n {
+                                return 0, fmt.Errorf("DQT segment too short")
+                        }
+
+                        for coefindex := 0; coefindex < 64 && a < n; coefindex++ {
+                                var val int
+
+                                if tableindex>>4 != 0 {
+                                        temp := int(tabuf[a])
+                                        a++
+                                        temp *= 256
+                                        val = int(tabuf[a]) + temp
+                                        a++
+                                } else {
+                                        val = int(tabuf[a])
+                                        a++
+                                }
+
+                                // scaling factor in percent
+                                x := 100.0 * float64(val) / float64(reftable[coefindex])
+                                cumsf += x
+                                cumsf2 += x * x
+
+                                // separate check for all-ones table (Q 100)
+                                if val != 1 {
+                                        allones = 0
+                                }
+                        }
+
+                        if 0 != len(reftable) { // terse output includes quality
+                                var qual float64
+                                cumsf /= 64.0 // mean scale factor
+                                cumsf2 /= 64.0
+
+                                if allones == 1 { // special case for all-ones table
+                                        qual = 100.0
+                                } else if cumsf <= 100.0 {
+                                        qual = (200.0 - cumsf) / 2.0
+                                } else {
+                                        qual = 5000.0 / cumsf
+                                }
+
+                                if tableindex == 0 {
+                                        return (int)(qual + 0.5), nil
+                                }
+                        }
+                }
+        }
+}