Optimize YCbCr image resize

converter.go

@@ -16,10 +16,7 @@ THIS SOFTWARE.
 
 package resize
 
-import (
+import "image"
-	"image"
-	"image/color"
-)
 
 // Keep value in [0,255] range.
 func clampUint8(in int32) uint8 {
@@ -257,19 +254,81 @@ func resizeGray16(in *image.Gray16, out *image.Gray16, scale float64, coeffs []i
 	}
 }
 
-func convertYCbCrToRGBA(in *image.YCbCr) *image.RGBA {
+func resizeYCbCr(in *ycc, out *ycc, scale float64, coeffs []int16, offset []int, filterLength int) {
-	out := image.NewRGBA(in.Bounds())
+	oldBounds := in.Bounds()
-	for y := 0; y < out.Bounds().Dy(); y++ {
+	newBounds := out.Bounds()
-		for x := 0; x < out.Bounds().Dx(); x++ {
+	minX := oldBounds.Min.X * 3
-			p := out.Pix[y*out.Stride+4*x:]
+	maxX := (oldBounds.Max.X - oldBounds.Min.X - 1) * 3
-			yi := in.YOffset(x, y)
+
-			ci := in.COffset(x, y)
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
-			r, g, b := color.YCbCrToRGB(in.Y[yi], in.Cb[ci], in.Cr[ci])
+		row := in.Pix[(x-oldBounds.Min.Y)*in.Stride:]
-			p[0] = r
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
-			p[1] = g
+			var p [3]int32
-			p[2] = b
+			var sum int32
-			p[3] = 0xff
+			start := offset[y]
+			ci := (y - newBounds.Min.Y) * filterLength
+			for i := 0; i < filterLength; i++ {
+				coeff := coeffs[ci+i]
+				if coeff != 0 {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(oldBounds.Max.X):
+						xi *= 3
+					case xi >= oldBounds.Max.X:
+						xi = maxX
+					default:
+						xi = minX
+					}
+					p[0] += int32(coeff) * int32(row[xi+0])
+					p[1] += int32(coeff) * int32(row[xi+1])
+					p[2] += int32(coeff) * int32(row[xi+2])
+					sum += int32(coeff)
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
+			out.Pix[xo+0] = clampUint8(p[0] / sum)
+			out.Pix[xo+1] = clampUint8(p[1] / sum)
+			out.Pix[xo+2] = clampUint8(p[2] / sum)
+		}
+	}
+}
+
+func nearestYCbCr(in *ycc, out *ycc, scale float64, coeffs []bool, offset []int, filterLength int) {
+	oldBounds := in.Bounds()
+	newBounds := out.Bounds()
+	minX := oldBounds.Min.X * 3
+	maxX := (oldBounds.Max.X - oldBounds.Min.X - 1) * 3
+
+	for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
+		row := in.Pix[(x-oldBounds.Min.Y)*in.Stride:]
+		for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
+			var p [3]float32
+			var sum float32
+			start := offset[y]
+			ci := (y - newBounds.Min.Y) * filterLength
+			for i := 0; i < filterLength; i++ {
+				if coeffs[ci+i] {
+					xi := start + i
+					switch {
+					case uint(xi) < uint(oldBounds.Max.X):
+						xi *= 3
+					case xi >= oldBounds.Max.X:
+						xi = maxX
+					default:
+						xi = minX
+					}
+					p[0] += float32(row[xi+0])
+					p[1] += float32(row[xi+1])
+					p[2] += float32(row[xi+2])
+					sum++
+				}
+			}
+
+			xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
+			out.Pix[xo+0] = floatToUint8(p[0] / sum)
+			out.Pix[xo+1] = floatToUint8(p[1] / sum)
+			out.Pix[xo+2] = floatToUint8(p[2] / sum)
 		}
 	}
-	return out
 }

nearest.go

@@ -1,3 +1,19 @@
+/*
+Copyright (c) 2014, Charlie Vieth <charlie.vieth@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
 package resize
 
 import "image"

nearest_test.go

@@ -1,3 +1,19 @@
+/*
+Copyright (c) 2014, Charlie Vieth <charlie.vieth@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
 package resize
 
 import "testing"

resize.go

@@ -129,35 +129,33 @@ func Resize(width, height uint, img image.Image, interp InterpolationFunction) i
 	case *image.YCbCr:
 		// 8-bit precision
 		// accessing the YCbCr arrays in a tight loop is slow.
-		// converting the image before filtering will improve performance.
+		// converting the image to ycc increases performance by 2x.
-		inputAsRGBA := convertYCbCrToRGBA(input)
+		temp := newYCC(image.Rect(0, 0, input.Bounds().Dy(), int(width)), input.SubsampleRatio)
-		temp := image.NewRGBA(image.Rect(0, 0, input.Bounds().Dy(), int(width)))
+		result := newYCC(image.Rect(0, 0, int(width), int(height)), input.SubsampleRatio)
-		result := image.NewRGBA(image.Rect(0, 0, int(width), int(height)))
 
-		// horizontal filter, results in transposed temporary image
 		coeffs, offset, filterLength := createWeights8(temp.Bounds().Dy(), input.Bounds().Min.X, taps, blur, scaleX, kernel)
+		in := imageYCbCrToYCC(input)
 		wg.Add(cpus)
 		for i := 0; i < cpus; i++ {
-			slice := makeSlice(temp, i, cpus).(*image.RGBA)
+			slice := makeSlice(temp, i, cpus).(*ycc)
 			go func() {
 				defer wg.Done()
-				resizeRGBA(inputAsRGBA, slice, scaleX, coeffs, offset, filterLength)
+				resizeYCbCr(in, slice, scaleX, coeffs, offset, filterLength)
 			}()
 		}
 		wg.Wait()
 
-		// horizontal filter on transposed image, result is not transposed
 		coeffs, offset, filterLength = createWeights8(result.Bounds().Dy(), temp.Bounds().Min.X, taps, blur, scaleY, kernel)
 		wg.Add(cpus)
 		for i := 0; i < cpus; i++ {
-			slice := makeSlice(result, i, cpus).(*image.RGBA)
+			slice := makeSlice(result, i, cpus).(*ycc)
 			go func() {
 				defer wg.Done()
-				resizeRGBA(temp, slice, scaleY, coeffs, offset, filterLength)
+				resizeYCbCr(temp, slice, scaleY, coeffs, offset, filterLength)
 			}()
 		}
 		wg.Wait()
-		return result
+		return result.YCbCr()
 	case *image.RGBA64:
 		// 16-bit precision
 		temp := image.NewRGBA64(image.Rect(0, 0, input.Bounds().Dy(), int(width)))
@@ -315,35 +313,33 @@ func resizeNearest(width, height uint, scaleX, scaleY float64, img image.Image,
 	case *image.YCbCr:
 		// 8-bit precision
 		// accessing the YCbCr arrays in a tight loop is slow.
-		// converting the image before filtering will improve performance.
+		// converting the image to ycc increases performance by 2x.
-		inputAsRGBA := convertYCbCrToRGBA(input)
+		temp := newYCC(image.Rect(0, 0, input.Bounds().Dy(), int(width)), input.SubsampleRatio)
-		temp := image.NewRGBA(image.Rect(0, 0, input.Bounds().Dy(), int(width)))
+		result := newYCC(image.Rect(0, 0, int(width), int(height)), input.SubsampleRatio)
-		result := image.NewRGBA(image.Rect(0, 0, int(width), int(height)))
 
-		// horizontal filter, results in transposed temporary image
 		coeffs, offset, filterLength := createWeightsNearest(temp.Bounds().Dy(), input.Bounds().Min.X, taps, blur, scaleX)
+		in := imageYCbCrToYCC(input)
 		wg.Add(cpus)
 		for i := 0; i < cpus; i++ {
-			slice := makeSlice(temp, i, cpus).(*image.RGBA)
+			slice := makeSlice(temp, i, cpus).(*ycc)
 			go func() {
 				defer wg.Done()
-				nearestRGBA(inputAsRGBA, slice, scaleX, coeffs, offset, filterLength)
+				nearestYCbCr(in, slice, scaleX, coeffs, offset, filterLength)
 			}()
 		}
 		wg.Wait()
 
-		// horizontal filter on transposed image, result is not transposed
 		coeffs, offset, filterLength = createWeightsNearest(result.Bounds().Dy(), temp.Bounds().Min.X, taps, blur, scaleY)
 		wg.Add(cpus)
 		for i := 0; i < cpus; i++ {
-			slice := makeSlice(result, i, cpus).(*image.RGBA)
+			slice := makeSlice(result, i, cpus).(*ycc)
 			go func() {
 				defer wg.Done()
-				nearestRGBA(temp, slice, scaleY, coeffs, offset, filterLength)
+				nearestYCbCr(temp, slice, scaleY, coeffs, offset, filterLength)
 			}()
 		}
 		wg.Wait()
-		return result
+		return result.YCbCr()
 	case *image.RGBA64:
 		// 16-bit precision
 		temp := image.NewRGBA64(image.Rect(0, 0, input.Bounds().Dy(), int(width)))

ycc.go

@@ -0,0 +1,226 @@
+/*
+Copyright (c) 2014, Charlie Vieth <charlie.vieth@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+package resize
+
+import (
+	"image"
+	"image/color"
+)
+
+// ycc is an in memory YCbCr image.  The Y, Cb and Cr samples are held in a
+// single slice to increase resizing performance.
+type ycc struct {
+	// Pix holds the image's pixels, in Y, Cb, Cr order. The pixel at
+	// (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*3].
+	Pix []uint8
+	// Stride is the Pix stride (in bytes) between vertically adjacent pixels.
+	Stride int
+	// Rect is the image's bounds.
+	Rect image.Rectangle
+	// SubsampleRatio is the subsample ratio of the original YCbCr image.
+	SubsampleRatio image.YCbCrSubsampleRatio
+}
+
+// PixOffset returns the index of the first element of Pix that corresponds to
+// the pixel at (x, y).
+func (p *ycc) PixOffset(x, y int) int {
+	return (y * p.Stride) + (x * 3)
+}
+
+func (p *ycc) Bounds() image.Rectangle {
+	return p.Rect
+}
+
+func (p *ycc) ColorModel() color.Model {
+	return color.YCbCrModel
+}
+
+func (p *ycc) At(x, y int) color.Color {
+	if !(image.Point{x, y}.In(p.Rect)) {
+		return color.YCbCr{}
+	}
+	i := p.PixOffset(x, y)
+	return color.YCbCr{
+		p.Pix[i+0],
+		p.Pix[i+1],
+		p.Pix[i+2],
+	}
+}
+
+func (p *ycc) Opaque() bool {
+	return true
+}
+
+// SubImage returns an image representing the portion of the image p visible
+// through r. The returned value shares pixels with the original image.
+func (p *ycc) SubImage(r image.Rectangle) image.Image {
+	r = r.Intersect(p.Rect)
+	if r.Empty() {
+		return &ycc{SubsampleRatio: p.SubsampleRatio}
+	}
+	i := p.PixOffset(r.Min.X, r.Min.Y)
+	return &ycc{
+		Pix:            p.Pix[i:],
+		Stride:         p.Stride,
+		Rect:           r,
+		SubsampleRatio: p.SubsampleRatio,
+	}
+}
+
+// newYCC returns a new ycc with the given bounds and subsample ratio.
+func newYCC(r image.Rectangle, s image.YCbCrSubsampleRatio) *ycc {
+	w, h := r.Dx(), r.Dy()
+	buf := make([]uint8, 3*w*h)
+	return &ycc{Pix: buf, Stride: 3 * w, Rect: r, SubsampleRatio: s}
+}
+
+// YCbCr converts ycc to a YCbCr image with the same subsample ratio
+// as the YCbCr image that ycc was generated from.
+func (p *ycc) YCbCr() *image.YCbCr {
+	ycbcr := image.NewYCbCr(p.Rect, p.SubsampleRatio)
+	var off int
+
+	switch ycbcr.SubsampleRatio {
+	case image.YCbCrSubsampleRatio422:
+		for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
+			yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
+			cy := (y - ycbcr.Rect.Min.Y) * ycbcr.CStride
+			for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
+				xx := (x - ycbcr.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx/2
+				ycbcr.Y[yi] = p.Pix[off+0]
+				ycbcr.Cb[ci] = p.Pix[off+1]
+				ycbcr.Cr[ci] = p.Pix[off+2]
+				off += 3
+			}
+		}
+	case image.YCbCrSubsampleRatio420:
+		for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
+			yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
+			cy := (y/2 - ycbcr.Rect.Min.Y/2) * ycbcr.CStride
+			for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
+				xx := (x - ycbcr.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx/2
+				ycbcr.Y[yi] = p.Pix[off+0]
+				ycbcr.Cb[ci] = p.Pix[off+1]
+				ycbcr.Cr[ci] = p.Pix[off+2]
+				off += 3
+			}
+		}
+	case image.YCbCrSubsampleRatio440:
+		for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
+			yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
+			cy := (y/2 - ycbcr.Rect.Min.Y/2) * ycbcr.CStride
+			for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
+				xx := (x - ycbcr.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx
+				ycbcr.Y[yi] = p.Pix[off+0]
+				ycbcr.Cb[ci] = p.Pix[off+1]
+				ycbcr.Cr[ci] = p.Pix[off+2]
+				off += 3
+			}
+		}
+	default:
+		// Default to 4:4:4 subsampling.
+		for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
+			yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
+			cy := (y - ycbcr.Rect.Min.Y) * ycbcr.CStride
+			for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
+				xx := (x - ycbcr.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx
+				ycbcr.Y[yi] = p.Pix[off+0]
+				ycbcr.Cb[ci] = p.Pix[off+1]
+				ycbcr.Cr[ci] = p.Pix[off+2]
+				off += 3
+			}
+		}
+	}
+	return ycbcr
+}
+
+// imageYCbCrToYCC converts a YCbCr image to a ycc image for resizing.
+func imageYCbCrToYCC(in *image.YCbCr) *ycc {
+	w, h := in.Rect.Dx(), in.Rect.Dy()
+	buf := make([]uint8, 3*w*h)
+	p := ycc{Pix: buf, Stride: 3 * w, Rect: in.Rect, SubsampleRatio: in.SubsampleRatio}
+	var off int
+
+	switch in.SubsampleRatio {
+	case image.YCbCrSubsampleRatio422:
+		for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
+			yy := (y - in.Rect.Min.Y) * in.YStride
+			cy := (y - in.Rect.Min.Y) * in.CStride
+			for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
+				xx := (x - in.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx/2
+				p.Pix[off+0] = in.Y[yi]
+				p.Pix[off+1] = in.Cb[ci]
+				p.Pix[off+2] = in.Cr[ci]
+				off += 3
+			}
+		}
+	case image.YCbCrSubsampleRatio420:
+		for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
+			yy := (y - in.Rect.Min.Y) * in.YStride
+			cy := (y/2 - in.Rect.Min.Y/2) * in.CStride
+			for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
+				xx := (x - in.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx/2
+				p.Pix[off+0] = in.Y[yi]
+				p.Pix[off+1] = in.Cb[ci]
+				p.Pix[off+2] = in.Cr[ci]
+				off += 3
+			}
+		}
+	case image.YCbCrSubsampleRatio440:
+		for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
+			yy := (y - in.Rect.Min.Y) * in.YStride
+			cy := (y/2 - in.Rect.Min.Y/2) * in.CStride
+			for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
+				xx := (x - in.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx
+				p.Pix[off+0] = in.Y[yi]
+				p.Pix[off+1] = in.Cb[ci]
+				p.Pix[off+2] = in.Cr[ci]
+				off += 3
+			}
+		}
+	default:
+		// Default to 4:4:4 subsampling.
+		for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
+			yy := (y - in.Rect.Min.Y) * in.YStride
+			cy := (y - in.Rect.Min.Y) * in.CStride
+			for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
+				xx := (x - in.Rect.Min.X)
+				yi := yy + xx
+				ci := cy + xx
+				p.Pix[off+0] = in.Y[yi]
+				p.Pix[off+1] = in.Cb[ci]
+				p.Pix[off+2] = in.Cr[ci]
+				off += 3
+			}
+		}
+	}
+	return &p
+}

ycc_test.go

@@ -0,0 +1,121 @@
+/*
+Copyright (c) 2014, Charlie Vieth <charlie.vieth@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+
+package resize
+
+import (
+	"image"
+	"testing"
+)
+
+type Image interface {
+	image.Image
+	SubImage(image.Rectangle) image.Image
+}
+
+func TestImage(t *testing.T) {
+	testImage := []Image{
+		newYCC(image.Rect(0, 0, 10, 10), image.YCbCrSubsampleRatio420),
+		newYCC(image.Rect(0, 0, 10, 10), image.YCbCrSubsampleRatio422),
+		newYCC(image.Rect(0, 0, 10, 10), image.YCbCrSubsampleRatio440),
+		newYCC(image.Rect(0, 0, 10, 10), image.YCbCrSubsampleRatio444),
+	}
+	for _, m := range testImage {
+		if !image.Rect(0, 0, 10, 10).Eq(m.Bounds()) {
+			t.Errorf("%T: want bounds %v, got %v",
+				m, image.Rect(0, 0, 10, 10), m.Bounds())
+			continue
+		}
+		m = m.SubImage(image.Rect(3, 2, 9, 8)).(Image)
+		if !image.Rect(3, 2, 9, 8).Eq(m.Bounds()) {
+			t.Errorf("%T: sub-image want bounds %v, got %v",
+				m, image.Rect(3, 2, 9, 8), m.Bounds())
+			continue
+		}
+		// Test that taking an empty sub-image starting at a corner does not panic.
+		m.SubImage(image.Rect(0, 0, 0, 0))
+		m.SubImage(image.Rect(10, 0, 10, 0))
+		m.SubImage(image.Rect(0, 10, 0, 10))
+		m.SubImage(image.Rect(10, 10, 10, 10))
+	}
+}
+
+func TestConvertYCbCr(t *testing.T) {
+	testImage := []Image{
+		image.NewYCbCr(image.Rect(0, 0, 50, 50), image.YCbCrSubsampleRatio420),
+		image.NewYCbCr(image.Rect(0, 0, 50, 50), image.YCbCrSubsampleRatio422),
+		image.NewYCbCr(image.Rect(0, 0, 50, 50), image.YCbCrSubsampleRatio440),
+		image.NewYCbCr(image.Rect(0, 0, 50, 50), image.YCbCrSubsampleRatio444),
+	}
+
+	for _, img := range testImage {
+		m := img.(*image.YCbCr)
+		for y := m.Rect.Min.Y; y < m.Rect.Max.Y; y++ {
+			for x := m.Rect.Min.X; x < m.Rect.Max.X; x++ {
+				yi := m.YOffset(x, y)
+				ci := m.COffset(x, y)
+				m.Y[yi] = uint8(16*y + x)
+				m.Cb[ci] = uint8(y + 16*x)
+				m.Cr[ci] = uint8(y + 16*x)
+			}
+		}
+
+		// test conversion from YCbCr to ycc
+		yc := imageYCbCrToYCC(m)
+		for y := m.Rect.Min.Y; y < m.Rect.Max.Y; y++ {
+			for x := m.Rect.Min.X; x < m.Rect.Max.X; x++ {
+				ystride := 3 * (m.Rect.Max.X - m.Rect.Min.X)
+				xstride := 3
+				yi := m.YOffset(x, y)
+				ci := m.COffset(x, y)
+				si := (y * ystride) + (x * xstride)
+				if m.Y[yi] != yc.Pix[si] {
+					t.Errorf("Err Y - found: %d expected: %d x: %d y: %d yi: %d si: %d",
+						m.Y[yi], yc.Pix[si], x, y, yi, si)
+				}
+				if m.Cb[ci] != yc.Pix[si+1] {
+					t.Errorf("Err Cb - found: %d expected: %d x: %d y: %d ci: %d si: %d",
+						m.Cb[ci], yc.Pix[si+1], x, y, ci, si+1)
+				}
+				if m.Cr[ci] != yc.Pix[si+2] {
+					t.Errorf("Err Cr - found: %d expected: %d x: %d y: %d ci: %d si: %d",
+						m.Cr[ci], yc.Pix[si+2], x, y, ci, si+2)
+				}
+			}
+		}
+
+		// test conversion from ycc back to YCbCr
+		ym := yc.YCbCr()
+		for y := m.Rect.Min.Y; y < m.Rect.Max.Y; y++ {
+			for x := m.Rect.Min.X; x < m.Rect.Max.X; x++ {
+				yi := m.YOffset(x, y)
+				ci := m.COffset(x, y)
+				if m.Y[yi] != ym.Y[yi] {
+					t.Errorf("Err Y - found: %d expected: %d x: %d y: %d yi: %d",
+						m.Y[yi], ym.Y[yi], x, y, yi)
+				}
+				if m.Cb[ci] != ym.Cb[ci] {
+					t.Errorf("Err Cb - found: %d expected: %d x: %d y: %d ci: %d",
+						m.Cb[ci], ym.Cb[ci], x, y, ci)
+				}
+				if m.Cr[ci] != ym.Cr[ci] {
+					t.Errorf("Err Cr - found: %d expected: %d x: %d y: %d ci: %d",
+						m.Cr[ci], ym.Cr[ci], x, y, ci)
+				}
+			}
+		}
+	}
+}