|
111
|
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 }
|
