...
Run Format

Source file src/image/color/ycbcr.go

Documentation: image/color

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     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  	// https://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'.
    14  
    15  	r1 := int32(r)
    16  	g1 := int32(g)
    17  	b1 := int32(b)
    18  
    19  	// yy is in range [0,0xff].
    20  	//
    21  	// Note that 19595 + 38470 + 7471 equals 65536.
    22  	yy := (19595*r1 + 38470*g1 + 7471*b1 + 1<<15) >> 16
    23  
    24  	// The bit twiddling below is equivalent to
    25  	//
    26  	// cb := (-11056*r1 - 21712*g1 + 32768*b1 + 257<<15) >> 16
    27  	// if cb < 0 {
    28  	//     cb = 0
    29  	// } else if cb > 0xff {
    30  	//     cb = ^int32(0)
    31  	// }
    32  	//
    33  	// but uses fewer branches and is faster.
    34  	// Note that the uint8 type conversion in the return
    35  	// statement will convert ^int32(0) to 0xff.
    36  	// The code below to compute cr uses a similar pattern.
    37  	//
    38  	// Note that -11056 - 21712 + 32768 equals 0.
    39  	cb := -11056*r1 - 21712*g1 + 32768*b1 + 257<<15
    40  	if uint32(cb)&0xff000000 == 0 {
    41  		cb >>= 16
    42  	} else {
    43  		cb = ^(cb >> 31)
    44  	}
    45  
    46  	// Note that 32768 - 27440 - 5328 equals 0.
    47  	cr := 32768*r1 - 27440*g1 - 5328*b1 + 257<<15
    48  	if uint32(cr)&0xff000000 == 0 {
    49  		cr >>= 16
    50  	} else {
    51  		cr = ^(cr >> 31)
    52  	}
    53  
    54  	return uint8(yy), uint8(cb), uint8(cr)
    55  }
    56  
    57  // YCbCrToRGB converts a Y'CbCr triple to an RGB triple.
    58  func YCbCrToRGB(y, cb, cr uint8) (uint8, uint8, uint8) {
    59  	// The JFIF specification says:
    60  	//	R = Y' + 1.40200*(Cr-128)
    61  	//	G = Y' - 0.34414*(Cb-128) - 0.71414*(Cr-128)
    62  	//	B = Y' + 1.77200*(Cb-128)
    63  	// https://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'.
    64  	//
    65  	// Those formulae use non-integer multiplication factors. When computing,
    66  	// integer math is generally faster than floating point math. We multiply
    67  	// all of those factors by 1<<16 and round to the nearest integer:
    68  	//	 91881 = roundToNearestInteger(1.40200 * 65536).
    69  	//	 22554 = roundToNearestInteger(0.34414 * 65536).
    70  	//	 46802 = roundToNearestInteger(0.71414 * 65536).
    71  	//	116130 = roundToNearestInteger(1.77200 * 65536).
    72  	//
    73  	// Adding a rounding adjustment in the range [0, 1<<16-1] and then shifting
    74  	// right by 16 gives us an integer math version of the original formulae.
    75  	//	R = (65536*Y' +  91881 *(Cr-128)                  + adjustment) >> 16
    76  	//	G = (65536*Y' -  22554 *(Cb-128) - 46802*(Cr-128) + adjustment) >> 16
    77  	//	B = (65536*Y' + 116130 *(Cb-128)                  + adjustment) >> 16
    78  	// A constant rounding adjustment of 1<<15, one half of 1<<16, would mean
    79  	// round-to-nearest when dividing by 65536 (shifting right by 16).
    80  	// Similarly, a constant rounding adjustment of 0 would mean round-down.
    81  	//
    82  	// Defining YY1 = 65536*Y' + adjustment simplifies the formulae and
    83  	// requires fewer CPU operations:
    84  	//	R = (YY1 +  91881 *(Cr-128)                 ) >> 16
    85  	//	G = (YY1 -  22554 *(Cb-128) - 46802*(Cr-128)) >> 16
    86  	//	B = (YY1 + 116130 *(Cb-128)                 ) >> 16
    87  	//
    88  	// The inputs (y, cb, cr) are 8 bit color, ranging in [0x00, 0xff]. In this
    89  	// function, the output is also 8 bit color, but in the related YCbCr.RGBA
    90  	// method, below, the output is 16 bit color, ranging in [0x0000, 0xffff].
    91  	// Outputting 16 bit color simply requires changing the 16 to 8 in the "R =
    92  	// etc >> 16" equation, and likewise for G and B.
    93  	//
    94  	// As mentioned above, a constant rounding adjustment of 1<<15 is a natural
    95  	// choice, but there is an additional constraint: if c0 := YCbCr{Y: y, Cb:
    96  	// 0x80, Cr: 0x80} and c1 := Gray{Y: y} then c0.RGBA() should equal
    97  	// c1.RGBA(). Specifically, if y == 0 then "R = etc >> 8" should yield
    98  	// 0x0000 and if y == 0xff then "R = etc >> 8" should yield 0xffff. If we
    99  	// used a constant rounding adjustment of 1<<15, then it would yield 0x0080
   100  	// and 0xff80 respectively.
   101  	//
   102  	// Note that when cb == 0x80 and cr == 0x80 then the formulae collapse to:
   103  	//	R = YY1 >> n
   104  	//	G = YY1 >> n
   105  	//	B = YY1 >> n
   106  	// where n is 16 for this function (8 bit color output) and 8 for the
   107  	// YCbCr.RGBA method (16 bit color output).
   108  	//
   109  	// The solution is to make the rounding adjustment non-constant, and equal
   110  	// to 257*Y', which ranges over [0, 1<<16-1] as Y' ranges over [0, 255].
   111  	// YY1 is then defined as:
   112  	//	YY1 = 65536*Y' + 257*Y'
   113  	// or equivalently:
   114  	//	YY1 = Y' * 0x10101
   115  	yy1 := int32(y) * 0x10101
   116  	cb1 := int32(cb) - 128
   117  	cr1 := int32(cr) - 128
   118  
   119  	// The bit twiddling below is equivalent to
   120  	//
   121  	// r := (yy1 + 91881*cr1) >> 16
   122  	// if r < 0 {
   123  	//     r = 0
   124  	// } else if r > 0xff {
   125  	//     r = ^int32(0)
   126  	// }
   127  	//
   128  	// but uses fewer branches and is faster.
   129  	// Note that the uint8 type conversion in the return
   130  	// statement will convert ^int32(0) to 0xff.
   131  	// The code below to compute g and b uses a similar pattern.
   132  	r := yy1 + 91881*cr1
   133  	if uint32(r)&0xff000000 == 0 {
   134  		r >>= 16
   135  	} else {
   136  		r = ^(r >> 31)
   137  	}
   138  
   139  	g := yy1 - 22554*cb1 - 46802*cr1
   140  	if uint32(g)&0xff000000 == 0 {
   141  		g >>= 16
   142  	} else {
   143  		g = ^(g >> 31)
   144  	}
   145  
   146  	b := yy1 + 116130*cb1
   147  	if uint32(b)&0xff000000 == 0 {
   148  		b >>= 16
   149  	} else {
   150  		b = ^(b >> 31)
   151  	}
   152  
   153  	return uint8(r), uint8(g), uint8(b)
   154  }
   155  
   156  // YCbCr represents a fully opaque 24-bit Y'CbCr color, having 8 bits each for
   157  // one luma and two chroma components.
   158  //
   159  // JPEG, VP8, the MPEG family and other codecs use this color model. Such
   160  // codecs often use the terms YUV and Y'CbCr interchangeably, but strictly
   161  // speaking, the term YUV applies only to analog video signals, and Y' (luma)
   162  // is Y (luminance) after applying gamma correction.
   163  //
   164  // Conversion between RGB and Y'CbCr is lossy and there are multiple, slightly
   165  // different formulae for converting between the two. This package follows
   166  // the JFIF specification at https://www.w3.org/Graphics/JPEG/jfif3.pdf.
   167  type YCbCr struct {
   168  	Y, Cb, Cr uint8
   169  }
   170  
   171  func (c YCbCr) RGBA() (uint32, uint32, uint32, uint32) {
   172  	// This code is a copy of the YCbCrToRGB function above, except that it
   173  	// returns values in the range [0, 0xffff] instead of [0, 0xff]. There is a
   174  	// subtle difference between doing this and having YCbCr satisfy the Color
   175  	// interface by first converting to an RGBA. The latter loses some
   176  	// information by going to and from 8 bits per channel.
   177  	//
   178  	// For example, this code:
   179  	//	const y, cb, cr = 0x7f, 0x7f, 0x7f
   180  	//	r, g, b := color.YCbCrToRGB(y, cb, cr)
   181  	//	r0, g0, b0, _ := color.YCbCr{y, cb, cr}.RGBA()
   182  	//	r1, g1, b1, _ := color.RGBA{r, g, b, 0xff}.RGBA()
   183  	//	fmt.Printf("0x%04x 0x%04x 0x%04x\n", r0, g0, b0)
   184  	//	fmt.Printf("0x%04x 0x%04x 0x%04x\n", r1, g1, b1)
   185  	// prints:
   186  	//	0x7e18 0x808d 0x7db9
   187  	//	0x7e7e 0x8080 0x7d7d
   188  
   189  	yy1 := int32(c.Y) * 0x10101
   190  	cb1 := int32(c.Cb) - 128
   191  	cr1 := int32(c.Cr) - 128
   192  
   193  	// The bit twiddling below is equivalent to
   194  	//
   195  	// r := (yy1 + 91881*cr1) >> 8
   196  	// if r < 0 {
   197  	//     r = 0
   198  	// } else if r > 0xff {
   199  	//     r = 0xffff
   200  	// }
   201  	//
   202  	// but uses fewer branches and is faster.
   203  	// The code below to compute g and b uses a similar pattern.
   204  	r := yy1 + 91881*cr1
   205  	if uint32(r)&0xff000000 == 0 {
   206  		r >>= 8
   207  	} else {
   208  		r = ^(r >> 31) & 0xffff
   209  	}
   210  
   211  	g := yy1 - 22554*cb1 - 46802*cr1
   212  	if uint32(g)&0xff000000 == 0 {
   213  		g >>= 8
   214  	} else {
   215  		g = ^(g >> 31) & 0xffff
   216  	}
   217  
   218  	b := yy1 + 116130*cb1
   219  	if uint32(b)&0xff000000 == 0 {
   220  		b >>= 8
   221  	} else {
   222  		b = ^(b >> 31) & 0xffff
   223  	}
   224  
   225  	return uint32(r), uint32(g), uint32(b), 0xffff
   226  }
   227  
   228  // YCbCrModel is the Model for Y'CbCr colors.
   229  var YCbCrModel Model = ModelFunc(yCbCrModel)
   230  
   231  func yCbCrModel(c Color) Color {
   232  	if _, ok := c.(YCbCr); ok {
   233  		return c
   234  	}
   235  	r, g, b, _ := c.RGBA()
   236  	y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
   237  	return YCbCr{y, u, v}
   238  }
   239  
   240  // NYCbCrA represents a non-alpha-premultiplied Y'CbCr-with-alpha color, having
   241  // 8 bits each for one luma, two chroma and one alpha component.
   242  type NYCbCrA struct {
   243  	YCbCr
   244  	A uint8
   245  }
   246  
   247  func (c NYCbCrA) RGBA() (uint32, uint32, uint32, uint32) {
   248  	// The first part of this method is the same as YCbCr.RGBA.
   249  	yy1 := int32(c.Y) * 0x10101
   250  	cb1 := int32(c.Cb) - 128
   251  	cr1 := int32(c.Cr) - 128
   252  
   253  	// The bit twiddling below is equivalent to
   254  	//
   255  	// r := (yy1 + 91881*cr1) >> 8
   256  	// if r < 0 {
   257  	//     r = 0
   258  	// } else if r > 0xff {
   259  	//     r = 0xffff
   260  	// }
   261  	//
   262  	// but uses fewer branches and is faster.
   263  	// The code below to compute g and b uses a similar pattern.
   264  	r := yy1 + 91881*cr1
   265  	if uint32(r)&0xff000000 == 0 {
   266  		r >>= 8
   267  	} else {
   268  		r = ^(r >> 31) & 0xffff
   269  	}
   270  
   271  	g := yy1 - 22554*cb1 - 46802*cr1
   272  	if uint32(g)&0xff000000 == 0 {
   273  		g >>= 8
   274  	} else {
   275  		g = ^(g >> 31) & 0xffff
   276  	}
   277  
   278  	b := yy1 + 116130*cb1
   279  	if uint32(b)&0xff000000 == 0 {
   280  		b >>= 8
   281  	} else {
   282  		b = ^(b >> 31) & 0xffff
   283  	}
   284  
   285  	// The second part of this method applies the alpha.
   286  	a := uint32(c.A) * 0x101
   287  	return uint32(r) * a / 0xffff, uint32(g) * a / 0xffff, uint32(b) * a / 0xffff, a
   288  }
   289  
   290  // NYCbCrAModel is the Model for non-alpha-premultiplied Y'CbCr-with-alpha
   291  // colors.
   292  var NYCbCrAModel Model = ModelFunc(nYCbCrAModel)
   293  
   294  func nYCbCrAModel(c Color) Color {
   295  	switch c := c.(type) {
   296  	case NYCbCrA:
   297  		return c
   298  	case YCbCr:
   299  		return NYCbCrA{c, 0xff}
   300  	}
   301  	r, g, b, a := c.RGBA()
   302  
   303  	// Convert from alpha-premultiplied to non-alpha-premultiplied.
   304  	if a != 0 {
   305  		r = (r * 0xffff) / a
   306  		g = (g * 0xffff) / a
   307  		b = (b * 0xffff) / a
   308  	}
   309  
   310  	y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
   311  	return NYCbCrA{YCbCr{Y: y, Cb: u, Cr: v}, uint8(a >> 8)}
   312  }
   313  
   314  // RGBToCMYK converts an RGB triple to a CMYK quadruple.
   315  func RGBToCMYK(r, g, b uint8) (uint8, uint8, uint8, uint8) {
   316  	rr := uint32(r)
   317  	gg := uint32(g)
   318  	bb := uint32(b)
   319  	w := rr
   320  	if w < gg {
   321  		w = gg
   322  	}
   323  	if w < bb {
   324  		w = bb
   325  	}
   326  	if w == 0 {
   327  		return 0, 0, 0, 0xff
   328  	}
   329  	c := (w - rr) * 0xff / w
   330  	m := (w - gg) * 0xff / w
   331  	y := (w - bb) * 0xff / w
   332  	return uint8(c), uint8(m), uint8(y), uint8(0xff - w)
   333  }
   334  
   335  // CMYKToRGB converts a CMYK quadruple to an RGB triple.
   336  func CMYKToRGB(c, m, y, k uint8) (uint8, uint8, uint8) {
   337  	w := 0xffff - uint32(k)*0x101
   338  	r := (0xffff - uint32(c)*0x101) * w / 0xffff
   339  	g := (0xffff - uint32(m)*0x101) * w / 0xffff
   340  	b := (0xffff - uint32(y)*0x101) * w / 0xffff
   341  	return uint8(r >> 8), uint8(g >> 8), uint8(b >> 8)
   342  }
   343  
   344  // CMYK represents a fully opaque CMYK color, having 8 bits for each of cyan,
   345  // magenta, yellow and black.
   346  //
   347  // It is not associated with any particular color profile.
   348  type CMYK struct {
   349  	C, M, Y, K uint8
   350  }
   351  
   352  func (c CMYK) RGBA() (uint32, uint32, uint32, uint32) {
   353  	// This code is a copy of the CMYKToRGB function above, except that it
   354  	// returns values in the range [0, 0xffff] instead of [0, 0xff].
   355  
   356  	w := 0xffff - uint32(c.K)*0x101
   357  	r := (0xffff - uint32(c.C)*0x101) * w / 0xffff
   358  	g := (0xffff - uint32(c.M)*0x101) * w / 0xffff
   359  	b := (0xffff - uint32(c.Y)*0x101) * w / 0xffff
   360  	return r, g, b, 0xffff
   361  }
   362  
   363  // CMYKModel is the Model for CMYK colors.
   364  var CMYKModel Model = ModelFunc(cmykModel)
   365  
   366  func cmykModel(c Color) Color {
   367  	if _, ok := c.(CMYK); ok {
   368  		return c
   369  	}
   370  	r, g, b, _ := c.RGBA()
   371  	cc, mm, yy, kk := RGBToCMYK(uint8(r>>8), uint8(g>>8), uint8(b>>8))
   372  	return CMYK{cc, mm, yy, kk}
   373  }
   374  

View as plain text