blob: 8b6d5085888b7ae308d9793f1cc8c08f34f8cf70 [file] [log] [blame]
 // Copyright 2011 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 color // RGBToYCbCr converts an RGB triple to a Y'CbCr triple. func RGBToYCbCr(r, g, b uint8) (uint8, uint8, uint8) { // The JFIF specification says: // Y' = 0.2990*R + 0.5870*G + 0.1140*B // Cb = -0.1687*R - 0.3313*G + 0.5000*B + 128 // Cr = 0.5000*R - 0.4187*G - 0.0813*B + 128 // https://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'. r1 := int32(r) g1 := int32(g) b1 := int32(b) // yy is in range [0,0xff]. // // Note that 19595 + 38470 + 7471 equals 65536. yy := (19595*r1 + 38470*g1 + 7471*b1 + 1<<15) >> 16 // The bit twiddling below is equivalent to // // cb := (-11056*r1 - 21712*g1 + 32768*b1 + 257<<15) >> 16 // if cb < 0 { // cb = 0 // } else if cb > 0xff { // cb = ^int32(0) // } // // but uses fewer branches and is faster. // Note that the uint8 type conversion in the return // statement will convert ^int32(0) to 0xff. // The code below to compute cr uses a similar pattern. // // Note that -11056 - 21712 + 32768 equals 0. cb := -11056*r1 - 21712*g1 + 32768*b1 + 257<<15 if uint32(cb)&0xff000000 == 0 { cb >>= 16 } else { cb = ^(cb >> 31) } // Note that 32768 - 27440 - 5328 equals 0. cr := 32768*r1 - 27440*g1 - 5328*b1 + 257<<15 if uint32(cr)&0xff000000 == 0 { cr >>= 16 } else { cr = ^(cr >> 31) } return uint8(yy), uint8(cb), uint8(cr) } // YCbCrToRGB converts a Y'CbCr triple to an RGB triple. func YCbCrToRGB(y, cb, cr uint8) (uint8, uint8, uint8) { // The JFIF specification says: // R = Y' + 1.40200*(Cr-128) // G = Y' - 0.34414*(Cb-128) - 0.71414*(Cr-128) // B = Y' + 1.77200*(Cb-128) // https://www.w3.org/Graphics/JPEG/jfif3.pdf says Y but means Y'. // // Those formulae use non-integer multiplication factors. When computing, // integer math is generally faster than floating point math. We multiply // all of those factors by 1<<16 and round to the nearest integer: // 91881 = roundToNearestInteger(1.40200 * 65536). // 22554 = roundToNearestInteger(0.34414 * 65536). // 46802 = roundToNearestInteger(0.71414 * 65536). // 116130 = roundToNearestInteger(1.77200 * 65536). // // Adding a rounding adjustment in the range [0, 1<<16-1] and then shifting // right by 16 gives us an integer math version of the original formulae. // R = (65536*Y' + 91881 *(Cr-128) + adjustment) >> 16 // G = (65536*Y' - 22554 *(Cb-128) - 46802*(Cr-128) + adjustment) >> 16 // B = (65536*Y' + 116130 *(Cb-128) + adjustment) >> 16 // A constant rounding adjustment of 1<<15, one half of 1<<16, would mean // round-to-nearest when dividing by 65536 (shifting right by 16). // Similarly, a constant rounding adjustment of 0 would mean round-down. // // Defining YY1 = 65536*Y' + adjustment simplifies the formulae and // requires fewer CPU operations: // R = (YY1 + 91881 *(Cr-128) ) >> 16 // G = (YY1 - 22554 *(Cb-128) - 46802*(Cr-128)) >> 16 // B = (YY1 + 116130 *(Cb-128) ) >> 16 // // The inputs (y, cb, cr) are 8 bit color, ranging in [0x00, 0xff]. In this // function, the output is also 8 bit color, but in the related YCbCr.RGBA // method, below, the output is 16 bit color, ranging in [0x0000, 0xffff]. // Outputting 16 bit color simply requires changing the 16 to 8 in the "R = // etc >> 16" equation, and likewise for G and B. // // As mentioned above, a constant rounding adjustment of 1<<15 is a natural // choice, but there is an additional constraint: if c0 := YCbCr{Y: y, Cb: // 0x80, Cr: 0x80} and c1 := Gray{Y: y} then c0.RGBA() should equal // c1.RGBA(). Specifically, if y == 0 then "R = etc >> 8" should yield // 0x0000 and if y == 0xff then "R = etc >> 8" should yield 0xffff. If we // used a constant rounding adjustment of 1<<15, then it would yield 0x0080 // and 0xff80 respectively. // // Note that when cb == 0x80 and cr == 0x80 then the formulae collapse to: // R = YY1 >> n // G = YY1 >> n // B = YY1 >> n // where n is 16 for this function (8 bit color output) and 8 for the // YCbCr.RGBA method (16 bit color output). // // The solution is to make the rounding adjustment non-constant, and equal // to 257*Y', which ranges over [0, 1<<16-1] as Y' ranges over [0, 255]. // YY1 is then defined as: // YY1 = 65536*Y' + 257*Y' // or equivalently: // YY1 = Y' * 0x10101 yy1 := int32(y) * 0x10101 cb1 := int32(cb) - 128 cr1 := int32(cr) - 128 // The bit twiddling below is equivalent to // // r := (yy1 + 91881*cr1) >> 16 // if r < 0 { // r = 0 // } else if r > 0xff { // r = ^int32(0) // } // // but uses fewer branches and is faster. // Note that the uint8 type conversion in the return // statement will convert ^int32(0) to 0xff. // The code below to compute g and b uses a similar pattern. r := yy1 + 91881*cr1 if uint32(r)&0xff000000 == 0 { r >>= 16 } else { r = ^(r >> 31) } g := yy1 - 22554*cb1 - 46802*cr1 if uint32(g)&0xff000000 == 0 { g >>= 16 } else { g = ^(g >> 31) } b := yy1 + 116130*cb1 if uint32(b)&0xff000000 == 0 { b >>= 16 } else { b = ^(b >> 31) } return uint8(r), uint8(g), uint8(b) } // YCbCr represents a fully opaque 24-bit Y'CbCr color, having 8 bits each for // one luma and two chroma components. // // JPEG, VP8, the MPEG family and other codecs use this color model. Such // codecs often use the terms YUV and Y'CbCr interchangeably, but strictly // speaking, the term YUV applies only to analog video signals, and Y' (luma) // is Y (luminance) after applying gamma correction. // // Conversion between RGB and Y'CbCr is lossy and there are multiple, slightly // different formulae for converting between the two. This package follows // the JFIF specification at https://www.w3.org/Graphics/JPEG/jfif3.pdf. type YCbCr struct { Y, Cb, Cr uint8 } func (c YCbCr) RGBA() (uint32, uint32, uint32, uint32) { // This code is a copy of the YCbCrToRGB function above, except that it // returns values in the range [0, 0xffff] instead of [0, 0xff]. There is a // subtle difference between doing this and having YCbCr satisfy the Color // interface by first converting to an RGBA. The latter loses some // information by going to and from 8 bits per channel. // // For example, this code: // const y, cb, cr = 0x7f, 0x7f, 0x7f // r, g, b := color.YCbCrToRGB(y, cb, cr) // r0, g0, b0, _ := color.YCbCr{y, cb, cr}.RGBA() // r1, g1, b1, _ := color.RGBA{r, g, b, 0xff}.RGBA() // fmt.Printf("0x%04x 0x%04x 0x%04x\n", r0, g0, b0) // fmt.Printf("0x%04x 0x%04x 0x%04x\n", r1, g1, b1) // prints: // 0x7e18 0x808d 0x7db9 // 0x7e7e 0x8080 0x7d7d yy1 := int32(c.Y) * 0x10101 cb1 := int32(c.Cb) - 128 cr1 := int32(c.Cr) - 128 // The bit twiddling below is equivalent to // // r := (yy1 + 91881*cr1) >> 8 // if r < 0 { // r = 0 // } else if r > 0xff { // r = 0xffff // } // // but uses fewer branches and is faster. // The code below to compute g and b uses a similar pattern. r := yy1 + 91881*cr1 if uint32(r)&0xff000000 == 0 { r >>= 8 } else { r = ^(r >> 31) & 0xffff } g := yy1 - 22554*cb1 - 46802*cr1 if uint32(g)&0xff000000 == 0 { g >>= 8 } else { g = ^(g >> 31) & 0xffff } b := yy1 + 116130*cb1 if uint32(b)&0xff000000 == 0 { b >>= 8 } else { b = ^(b >> 31) & 0xffff } return uint32(r), uint32(g), uint32(b), 0xffff } // YCbCrModel is the Model for Y'CbCr colors. var YCbCrModel Model = ModelFunc(yCbCrModel) func yCbCrModel(c Color) Color { if _, ok := c.(YCbCr); ok { return c } r, g, b, _ := c.RGBA() y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8)) return YCbCr{y, u, v} } // NYCbCrA represents a non-alpha-premultiplied Y'CbCr-with-alpha color, having // 8 bits each for one luma, two chroma and one alpha component. type NYCbCrA struct { YCbCr A uint8 } func (c NYCbCrA) RGBA() (uint32, uint32, uint32, uint32) { // The first part of this method is the same as YCbCr.RGBA. yy1 := int32(c.Y) * 0x10101 cb1 := int32(c.Cb) - 128 cr1 := int32(c.Cr) - 128 // The bit twiddling below is equivalent to // // r := (yy1 + 91881*cr1) >> 8 // if r < 0 { // r = 0 // } else if r > 0xff { // r = 0xffff // } // // but uses fewer branches and is faster. // The code below to compute g and b uses a similar pattern. r := yy1 + 91881*cr1 if uint32(r)&0xff000000 == 0 { r >>= 8 } else { r = ^(r >> 31) & 0xffff } g := yy1 - 22554*cb1 - 46802*cr1 if uint32(g)&0xff000000 == 0 { g >>= 8 } else { g = ^(g >> 31) & 0xffff } b := yy1 + 116130*cb1 if uint32(b)&0xff000000 == 0 { b >>= 8 } else { b = ^(b >> 31) & 0xffff } // The second part of this method applies the alpha. a := uint32(c.A) * 0x101 return uint32(r) * a / 0xffff, uint32(g) * a / 0xffff, uint32(b) * a / 0xffff, a } // NYCbCrAModel is the Model for non-alpha-premultiplied Y'CbCr-with-alpha // colors. var NYCbCrAModel Model = ModelFunc(nYCbCrAModel) func nYCbCrAModel(c Color) Color { switch c := c.(type) { case NYCbCrA: return c case YCbCr: return NYCbCrA{c, 0xff} } r, g, b, a := c.RGBA() // Convert from alpha-premultiplied to non-alpha-premultiplied. if a != 0 { r = (r * 0xffff) / a g = (g * 0xffff) / a b = (b * 0xffff) / a } y, u, v := RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8)) return NYCbCrA{YCbCr{Y: y, Cb: u, Cr: v}, uint8(a >> 8)} } // RGBToCMYK converts an RGB triple to a CMYK quadruple. func RGBToCMYK(r, g, b uint8) (uint8, uint8, uint8, uint8) { rr := uint32(r) gg := uint32(g) bb := uint32(b) w := rr if w < gg { w = gg } if w < bb { w = bb } if w == 0 { return 0, 0, 0, 0xff } c := (w - rr) * 0xff / w m := (w - gg) * 0xff / w y := (w - bb) * 0xff / w return uint8(c), uint8(m), uint8(y), uint8(0xff - w) } // CMYKToRGB converts a CMYK quadruple to an RGB triple. func CMYKToRGB(c, m, y, k uint8) (uint8, uint8, uint8) { w := 0xffff - uint32(k)*0x101 r := (0xffff - uint32(c)*0x101) * w / 0xffff g := (0xffff - uint32(m)*0x101) * w / 0xffff b := (0xffff - uint32(y)*0x101) * w / 0xffff return uint8(r >> 8), uint8(g >> 8), uint8(b >> 8) } // CMYK represents a fully opaque CMYK color, having 8 bits for each of cyan, // magenta, yellow and black. // // It is not associated with any particular color profile. type CMYK struct { C, M, Y, K uint8 } func (c CMYK) RGBA() (uint32, uint32, uint32, uint32) { // This code is a copy of the CMYKToRGB function above, except that it // returns values in the range [0, 0xffff] instead of [0, 0xff]. w := 0xffff - uint32(c.K)*0x101 r := (0xffff - uint32(c.C)*0x101) * w / 0xffff g := (0xffff - uint32(c.M)*0x101) * w / 0xffff b := (0xffff - uint32(c.Y)*0x101) * w / 0xffff return r, g, b, 0xffff } // CMYKModel is the Model for CMYK colors. var CMYKModel Model = ModelFunc(cmykModel) func cmykModel(c Color) Color { if _, ok := c.(CMYK); ok { return c } r, g, b, _ := c.RGBA() cc, mm, yy, kk := RGBToCMYK(uint8(r>>8), uint8(g>>8), uint8(b>>8)) return CMYK{cc, mm, yy, kk} }