code review 146910043: vp8l: update comments to match latest spec.

vp8l/decode.go

 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package vp8l implements a decoder for the VP8L lossless image format.
 //
 // The VP8L specification is at:
 // https://developers.google.com/speed/webp/docs/riff_container
 package vp8l
 
@@ skipping 112 matching lines @@
                 pix, err := d.decodePix(int32(nColors), 1, 4*256, false)
                 if err != nil {
                         return transform{}, 0, err
                 }
                 for p := 4; p < len(pix); p += 4 {
                         pix[p+0] += pix[p-4]
                         pix[p+1] += pix[p-3]
                         pix[p+2] += pix[p-2]
                         pix[p+3] += pix[p-1]
                 }
-                // The C code fills in palette entries past the nColors upper limit as
-                // transparent black. In Go, we re-slice up to 256 4-byte pixels.
+                // The spec says that "if the index is equal or larger than color_table_size,
+                // the argb color value should be set to 0x00000000 (transparent black)."
+                // We re-slice up to 256 4-byte pixels.
                 t.pix = pix[:4*256]
         }
         return t, w, nil
 }
 
 // repeatsCodeLength is the minimum code length for repeated codes.
 const repeatsCodeLength = 16
 
 // These magic numbers are specified at the end of section 5.2.2.
 // The 3-length arrays apply to code lengths >= repeatsCodeLength.
@@ skipping 378 matching lines @@
         height++
         _, err = d.read(1) // Read and ignore the hasAlpha hint.
         if err != nil {
                 return nil, 0, 0, err
         }
         version, err := d.read(3)
         if err != nil {
                 return nil, 0, 0, err
         }
         if version != 0 {
-                return nil, 0, 0, errors.New("vp8l: unsupported version")
+                return nil, 0, 0, errors.New("vp8l: invalid version")
         }
         return d, int32(width), int32(height), nil
 }
 
 // DecodeConfig decodes the color model and dimensions of a VP8L image from r.
 func DecodeConfig(r io.Reader) (image.Config, error) {
         _, w, h, err := decodeHeader(r)
         if err != nil {
                 return image.Config{}, err
         }
@@ skipping 46 matching lines @@
         for i := nTransforms - 1; i >= 0; i-- {
                 t := &transforms[i]
                 pix = inverseTransforms[t.transformType](t, pix, h)
         }
         return &image.NRGBA{
                 Pix:    pix,
                 Stride: 4 * int(originalW),
                 Rect:   image.Rect(0, 0, int(originalW), int(h)),
         }, nil
 }