...

# Source file src/pkg/image/color/ycbcr.go

```     1	// Copyright 2011 The Go Authors. All rights reserved.
2	// Use of this source code is governed by a BSD-style
4
5	package color
6
7	// RGBToYCbCr converts an RGB triple to a Y'CbCr triple.
8	func RGBToYCbCr(r, g, b uint8) (uint8, uint8, uint8) {
9		// The JFIF specification says:
10		//	Y' =  0.2990*R + 0.5870*G + 0.1140*B
11		//	Cb = -0.1687*R - 0.3313*G + 0.5000*B + 128
12		//	Cr =  0.5000*R - 0.4187*G - 0.0813*B + 128
13		// http://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'.
14		r1 := int(r)
15		g1 := int(g)
16		b1 := int(b)
17		yy := (19595*r1 + 38470*g1 + 7471*b1 + 1<<15) >> 16
18		cb := (-11056*r1 - 21712*g1 + 32768*b1 + 257<<15) >> 16
19		cr := (32768*r1 - 27440*g1 - 5328*b1 + 257<<15) >> 16
20		if yy < 0 {
21			yy = 0
22		} else if yy > 255 {
23			yy = 255
24		}
25		if cb < 0 {
26			cb = 0
27		} else if cb > 255 {
28			cb = 255
29		}
30		if cr < 0 {
31			cr = 0
32		} else if cr > 255 {
33			cr = 255
34		}
35		return uint8(yy), uint8(cb), uint8(cr)
36	}
37
38	// YCbCrToRGB converts a Y'CbCr triple to an RGB triple.
39	func YCbCrToRGB(y, cb, cr uint8) (uint8, uint8, uint8) {
40		// The JFIF specification says:
41		//	R = Y' + 1.40200*(Cr-128)
42		//	G = Y' - 0.34414*(Cb-128) - 0.71414*(Cr-128)
43		//	B = Y' + 1.77200*(Cb-128)
44		// http://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'.
45		yy1 := int(y)<<16 + 1<<15
46		cb1 := int(cb) - 128
47		cr1 := int(cr) - 128
48		r := (yy1 + 91881*cr1) >> 16
49		g := (yy1 - 22554*cb1 - 46802*cr1) >> 16
50		b := (yy1 + 116130*cb1) >> 16
51		if r < 0 {
52			r = 0
53		} else if r > 255 {
54			r = 255
55		}
56		if g < 0 {
57			g = 0
58		} else if g > 255 {
59			g = 255
60		}
61		if b < 0 {
62			b = 0
63		} else if b > 255 {
64			b = 255
65		}
66		return uint8(r), uint8(g), uint8(b)
67	}
68
69	// YCbCr represents a fully opaque 24-bit Y'CbCr color, having 8 bits each for
70	// one luma and two chroma components.
71	//
72	// JPEG, VP8, the MPEG family and other codecs use this color model. Such
73	// codecs often use the terms YUV and Y'CbCr interchangeably, but strictly
74	// speaking, the term YUV applies only to analog video signals, and Y' (luma)
75	// is Y (luminance) after applying gamma correction.
76	//
77	// Conversion between RGB and Y'CbCr is lossy and there are multiple, slightly
78	// different formulae for converting between the two. This package follows
79	// the JFIF specification at http://www.w3.org/Graphics/JPEG/jfif3.pdf.
80	type YCbCr struct {
81		Y, Cb, Cr uint8
82	}
83
84	func (c YCbCr) RGBA() (uint32, uint32, uint32, uint32) {
85		r, g, b := YCbCrToRGB(c.Y, c.Cb, c.Cr)
86		return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
87	}
88
89	// YCbCrModel is the Model for Y'CbCr colors.
90	var YCbCrModel Model = ModelFunc(yCbCrModel)
91
92	func yCbCrModel(c Color) Color {
93		if _, ok := c.(YCbCr); ok {
94			return c
95		}
96		r, g, b, _ := c.RGBA()
97		y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
98		return YCbCr{y, u, v}
99	}
100
```

View as plain text