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 image 6 7 import ( 8 "image/color" 9 ) 10 11 // YCbCrSubsampleRatio is the chroma subsample ratio used in a YCbCr image. 12 type YCbCrSubsampleRatio int 13 14 const ( 15 YCbCrSubsampleRatio444 YCbCrSubsampleRatio = iota 16 YCbCrSubsampleRatio422 17 YCbCrSubsampleRatio420 18 YCbCrSubsampleRatio440 19 YCbCrSubsampleRatio411 20 YCbCrSubsampleRatio410 21 ) 22 23 func (s YCbCrSubsampleRatio) String() string { 24 switch s { 25 case YCbCrSubsampleRatio444: 26 return "YCbCrSubsampleRatio444" 27 case YCbCrSubsampleRatio422: 28 return "YCbCrSubsampleRatio422" 29 case YCbCrSubsampleRatio420: 30 return "YCbCrSubsampleRatio420" 31 case YCbCrSubsampleRatio440: 32 return "YCbCrSubsampleRatio440" 33 case YCbCrSubsampleRatio411: 34 return "YCbCrSubsampleRatio411" 35 case YCbCrSubsampleRatio410: 36 return "YCbCrSubsampleRatio410" 37 } 38 return "YCbCrSubsampleRatioUnknown" 39 } 40 41 // YCbCr is an in-memory image of Y'CbCr colors. There is one Y sample per 42 // pixel, but each Cb and Cr sample can span one or more pixels. 43 // YStride is the Y slice index delta between vertically adjacent pixels. 44 // CStride is the Cb and Cr slice index delta between vertically adjacent pixels 45 // that map to separate chroma samples. 46 // It is not an absolute requirement, but YStride and len(Y) are typically 47 // multiples of 8, and: 48 // For 4:4:4, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/1. 49 // For 4:2:2, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/2. 50 // For 4:2:0, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/4. 51 // For 4:4:0, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/2. 52 // For 4:1:1, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/4. 53 // For 4:1:0, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/8. 54 type YCbCr struct { 55 Y, Cb, Cr []uint8 56 YStride int 57 CStride int 58 SubsampleRatio YCbCrSubsampleRatio 59 Rect Rectangle 60 } 61 62 func (p *YCbCr) ColorModel() color.Model { 63 return color.YCbCrModel 64 } 65 66 func (p *YCbCr) Bounds() Rectangle { 67 return p.Rect 68 } 69 70 func (p *YCbCr) At(x, y int) color.Color { 71 return p.YCbCrAt(x, y) 72 } 73 74 func (p *YCbCr) YCbCrAt(x, y int) color.YCbCr { 75 if !(Point{x, y}.In(p.Rect)) { 76 return color.YCbCr{} 77 } 78 yi := p.YOffset(x, y) 79 ci := p.COffset(x, y) 80 return color.YCbCr{ 81 p.Y[yi], 82 p.Cb[ci], 83 p.Cr[ci], 84 } 85 } 86 87 // YOffset returns the index of the first element of Y that corresponds to 88 // the pixel at (x, y). 89 func (p *YCbCr) YOffset(x, y int) int { 90 return (y-p.Rect.Min.Y)*p.YStride + (x - p.Rect.Min.X) 91 } 92 93 // COffset returns the index of the first element of Cb or Cr that corresponds 94 // to the pixel at (x, y). 95 func (p *YCbCr) COffset(x, y int) int { 96 switch p.SubsampleRatio { 97 case YCbCrSubsampleRatio422: 98 return (y-p.Rect.Min.Y)*p.CStride + (x/2 - p.Rect.Min.X/2) 99 case YCbCrSubsampleRatio420: 100 return (y/2-p.Rect.Min.Y/2)*p.CStride + (x/2 - p.Rect.Min.X/2) 101 case YCbCrSubsampleRatio440: 102 return (y/2-p.Rect.Min.Y/2)*p.CStride + (x - p.Rect.Min.X) 103 case YCbCrSubsampleRatio411: 104 return (y-p.Rect.Min.Y)*p.CStride + (x/4 - p.Rect.Min.X/4) 105 case YCbCrSubsampleRatio410: 106 return (y/2-p.Rect.Min.Y/2)*p.CStride + (x/4 - p.Rect.Min.X/4) 107 } 108 // Default to 4:4:4 subsampling. 109 return (y-p.Rect.Min.Y)*p.CStride + (x - p.Rect.Min.X) 110 } 111 112 // SubImage returns an image representing the portion of the image p visible 113 // through r. The returned value shares pixels with the original image. 114 func (p *YCbCr) SubImage(r Rectangle) Image { 115 r = r.Intersect(p.Rect) 116 // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside 117 // either r1 or r2 if the intersection is empty. Without explicitly checking for 118 // this, the Pix[i:] expression below can panic. 119 if r.Empty() { 120 return &YCbCr{ 121 SubsampleRatio: p.SubsampleRatio, 122 } 123 } 124 yi := p.YOffset(r.Min.X, r.Min.Y) 125 ci := p.COffset(r.Min.X, r.Min.Y) 126 return &YCbCr{ 127 Y: p.Y[yi:], 128 Cb: p.Cb[ci:], 129 Cr: p.Cr[ci:], 130 SubsampleRatio: p.SubsampleRatio, 131 YStride: p.YStride, 132 CStride: p.CStride, 133 Rect: r, 134 } 135 } 136 137 func (p *YCbCr) Opaque() bool { 138 return true 139 } 140 141 func yCbCrSize(r Rectangle, subsampleRatio YCbCrSubsampleRatio) (w, h, cw, ch int) { 142 w, h = r.Dx(), r.Dy() 143 switch subsampleRatio { 144 case YCbCrSubsampleRatio422: 145 cw = (r.Max.X+1)/2 - r.Min.X/2 146 ch = h 147 case YCbCrSubsampleRatio420: 148 cw = (r.Max.X+1)/2 - r.Min.X/2 149 ch = (r.Max.Y+1)/2 - r.Min.Y/2 150 case YCbCrSubsampleRatio440: 151 cw = w 152 ch = (r.Max.Y+1)/2 - r.Min.Y/2 153 case YCbCrSubsampleRatio411: 154 cw = (r.Max.X+3)/4 - r.Min.X/4 155 ch = h 156 case YCbCrSubsampleRatio410: 157 cw = (r.Max.X+3)/4 - r.Min.X/4 158 ch = (r.Max.Y+1)/2 - r.Min.Y/2 159 default: 160 // Default to 4:4:4 subsampling. 161 cw = w 162 ch = h 163 } 164 return 165 } 166 167 // NewYCbCr returns a new YCbCr image with the given bounds and subsample 168 // ratio. 169 func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr { 170 w, h, cw, ch := yCbCrSize(r, subsampleRatio) 171 i0 := w*h + 0*cw*ch 172 i1 := w*h + 1*cw*ch 173 i2 := w*h + 2*cw*ch 174 b := make([]byte, i2) 175 return &YCbCr{ 176 Y: b[:i0:i0], 177 Cb: b[i0:i1:i1], 178 Cr: b[i1:i2:i2], 179 SubsampleRatio: subsampleRatio, 180 YStride: w, 181 CStride: cw, 182 Rect: r, 183 } 184 } 185 186 // NYCbCrA is an in-memory image of non-alpha-premultiplied Y'CbCr-with-alpha 187 // colors. A and AStride are analogous to the Y and YStride fields of the 188 // embedded YCbCr. 189 type NYCbCrA struct { 190 YCbCr 191 A []uint8 192 AStride int 193 } 194 195 func (p *NYCbCrA) ColorModel() color.Model { 196 return color.NYCbCrAModel 197 } 198 199 func (p *NYCbCrA) At(x, y int) color.Color { 200 return p.NYCbCrAAt(x, y) 201 } 202 203 func (p *NYCbCrA) NYCbCrAAt(x, y int) color.NYCbCrA { 204 if !(Point{X: x, Y: y}.In(p.Rect)) { 205 return color.NYCbCrA{} 206 } 207 yi := p.YOffset(x, y) 208 ci := p.COffset(x, y) 209 ai := p.AOffset(x, y) 210 return color.NYCbCrA{ 211 color.YCbCr{ 212 Y: p.Y[yi], 213 Cb: p.Cb[ci], 214 Cr: p.Cr[ci], 215 }, 216 p.A[ai], 217 } 218 } 219 220 // AOffset returns the index of the first element of A that corresponds to the 221 // pixel at (x, y). 222 func (p *NYCbCrA) AOffset(x, y int) int { 223 return (y-p.Rect.Min.Y)*p.AStride + (x - p.Rect.Min.X) 224 } 225 226 // SubImage returns an image representing the portion of the image p visible 227 // through r. The returned value shares pixels with the original image. 228 func (p *NYCbCrA) SubImage(r Rectangle) Image { 229 r = r.Intersect(p.Rect) 230 // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside 231 // either r1 or r2 if the intersection is empty. Without explicitly checking for 232 // this, the Pix[i:] expression below can panic. 233 if r.Empty() { 234 return &NYCbCrA{ 235 YCbCr: YCbCr{ 236 SubsampleRatio: p.SubsampleRatio, 237 }, 238 } 239 } 240 yi := p.YOffset(r.Min.X, r.Min.Y) 241 ci := p.COffset(r.Min.X, r.Min.Y) 242 ai := p.AOffset(r.Min.X, r.Min.Y) 243 return &NYCbCrA{ 244 YCbCr: YCbCr{ 245 Y: p.Y[yi:], 246 Cb: p.Cb[ci:], 247 Cr: p.Cr[ci:], 248 SubsampleRatio: p.SubsampleRatio, 249 YStride: p.YStride, 250 CStride: p.CStride, 251 Rect: r, 252 }, 253 A: p.A[ai:], 254 AStride: p.AStride, 255 } 256 } 257 258 // Opaque scans the entire image and reports whether it is fully opaque. 259 func (p *NYCbCrA) Opaque() bool { 260 if p.Rect.Empty() { 261 return true 262 } 263 i0, i1 := 0, p.Rect.Dx() 264 for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { 265 for _, a := range p.A[i0:i1] { 266 if a != 0xff { 267 return false 268 } 269 } 270 i0 += p.AStride 271 i1 += p.AStride 272 } 273 return true 274 } 275 276 // NewNYCbCrA returns a new NYCbCrA image with the given bounds and subsample 277 // ratio. 278 func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA { 279 w, h, cw, ch := yCbCrSize(r, subsampleRatio) 280 i0 := 1*w*h + 0*cw*ch 281 i1 := 1*w*h + 1*cw*ch 282 i2 := 1*w*h + 2*cw*ch 283 i3 := 2*w*h + 2*cw*ch 284 b := make([]byte, i3) 285 return &NYCbCrA{ 286 YCbCr: YCbCr{ 287 Y: b[:i0:i0], 288 Cb: b[i0:i1:i1], 289 Cr: b[i1:i2:i2], 290 SubsampleRatio: subsampleRatio, 291 YStride: w, 292 CStride: cw, 293 Rect: r, 294 }, 295 A: b[i2:], 296 AStride: w, 297 } 298 } 299
View as plain text