1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
// // Copyright 2012 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 image
// import (
// "image/color"
// "testing"
// )
// func TestYCbCr(t *testing.T) {
// rects := []Rectangle{
// Rect(0, 0, 16, 16),
// Rect(1, 0, 16, 16),
// Rect(0, 1, 16, 16),
// Rect(1, 1, 16, 16),
// Rect(1, 1, 15, 16),
// Rect(1, 1, 16, 15),
// Rect(1, 1, 15, 15),
// Rect(2, 3, 14, 15),
// Rect(7, 0, 7, 16),
// Rect(0, 8, 16, 8),
// Rect(0, 0, 10, 11),
// Rect(5, 6, 16, 16),
// Rect(7, 7, 8, 8),
// Rect(7, 8, 8, 9),
// Rect(8, 7, 9, 8),
// Rect(8, 8, 9, 9),
// Rect(7, 7, 17, 17),
// Rect(8, 8, 17, 17),
// Rect(9, 9, 17, 17),
// Rect(10, 10, 17, 17),
// }
// subsampleRatios := []YCbCrSubsampleRatio{
// YCbCrSubsampleRatio444,
// YCbCrSubsampleRatio422,
// YCbCrSubsampleRatio420,
// YCbCrSubsampleRatio440,
// YCbCrSubsampleRatio411,
// YCbCrSubsampleRatio410,
// }
// deltas := []Point{
// Pt(0, 0),
// Pt(1000, 1001),
// Pt(5001, -400),
// Pt(-701, -801),
// }
// for _, r := range rects {
// for _, subsampleRatio := range subsampleRatios {
// for _, delta := range deltas {
// testYCbCr(t, r, subsampleRatio, delta)
// }
// }
// if testing.Short() {
// break
// }
// }
// }
// func testYCbCr(t *testing.T, r Rectangle, subsampleRatio YCbCrSubsampleRatio, delta Point) {
// // Create a YCbCr image m, whose bounds are r translated by (delta.x, delta.y).
// r1 := r.Add(delta)
// m := NewYCbCr(r1, subsampleRatio)
// // Test that the image buffer is reasonably small even if (delta.x, delta.y) is far from the origin.
// if len(m.y) > 100*100 {
// t.Errorf("r=%v, subsampleRatio=%v, delta=%v: image buffer is too large",
// r, subsampleRatio, delta)
// return
// }
// // Initialize m's pixels. For 422 and 420 subsampling, some of the Cb and Cr elements
// // will be set multiple times. That's OK. We just want to avoid a uniform image.
// for y := r1.min.y; y < r1.max.y; y++ {
// for x := r1.min.x; x < r1.max.x; x++ {
// yi := m.YOffset(x, y)
// ci := m.COffset(x, y)
// m.y[yi] = uint8(16*y + x)
// m.Cb[ci] = uint8(y + 16*x)
// m.Cr[ci] = uint8(y + 16*x)
// }
// }
// // Make various sub-images of m.
// for y0 := delta.y + 3; y0 < delta.y+7; y0++ {
// for y1 := delta.y + 8; y1 < delta.y+13; y1++ {
// for x0 := delta.x + 3; x0 < delta.x+7; x0++ {
// for x1 := delta.x + 8; x1 < delta.x+13; x1++ {
// subRect := Rect(x0, y0, x1, y1)
// sub := m.SubImage(subRect).(*YCbCr)
// // For each point in the sub-image's bounds, check that m.At(x, y) equals sub.At(x, y).
// for y := sub.Rect.min.y; y < sub.Rect.max.y; y++ {
// for x := sub.Rect.min.x; x < sub.Rect.max.x; x++ {
// color0 := m.At(x, y).(color.YCbCr)
// color1 := sub.At(x, y).(color.YCbCr)
// if color0 != color1 {
// t.Errorf("r=%v, subsampleRatio=%v, delta=%v, x=%d, y=%d, color0=%v, color1=%v",
// r, subsampleRatio, delta, x, y, color0, color1)
// return
// }
// }
// }
// }
// }
// }
// }
// }
// func TestYCbCrSlicesDontOverlap(t *testing.T) {
// m := NewYCbCr(Rect(0, 0, 8, 8), YCbCrSubsampleRatio420)
// names := []string{"Y", "Cb", "Cr"}
// slices := [][]byte{
// m.y[:cap(m.y)],
// m.Cb[:cap(m.Cb)],
// m.Cr[:cap(m.Cr)],
// }
// for i, slice := range slices {
// want := uint8(10 + i)
// for j := range slice {
// slice[j] = want
// }
// }
// for i, slice := range slices {
// want := uint8(10 + i)
// for j, got := range slice {
// if got != want {
// t.Fatalf("m.%s[%d]: got %d, want %d", names[i], j, got, want)
// }
// }
// }
// }