git clone https://git.lucas.co/go_mono.git
vp8/predfunc.go (12.7K)
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 vp8
6
7 // This file implements the prediction functions, as specified in chapter 12.
8 //
9 // For each macroblock (of 1x16x16 luma and 2x8x8 chroma coefficients), the
10 // luma values are either predicted as one large 16x16 region or 16 separate
11 // 4x4 regions. The chroma values are always predicted as one 8x8 region.
12 //
13 // For 4x4 regions, the target block's predicted values (Xs) are a function of
14 // its previously-decoded top and left border values, as well as a number of
15 // pixels from the top-right:
16 //
17 // a b c d e f g h
18 // p X X X X
19 // q X X X X
20 // r X X X X
21 // s X X X X
22 //
23 // The predictor modes are:
24 // - DC: all Xs = (b + c + d + e + p + q + r + s + 4) / 8.
25 // - TM: the first X = (b + p - a), the second X = (c + p - a), and so on.
26 // - VE: each X = the weighted average of its column's top value and that
27 // value's neighbors, i.e. averages of abc, bcd, cde or def.
28 // - HE: similar to VE except rows instead of columns, and the final row is
29 // an average of r, s and s.
30 // - RD, VR, LD, VL, HD, HU: these diagonal modes ("Right Down", "Vertical
31 // Right", etc) are more complicated and are described in section 12.3.
32 // All Xs are clipped to the range [0, 255].
33 //
34 // For 8x8 and 16x16 regions, the target block's predicted values are a
35 // function of the top and left border values without the top-right overhang,
36 // i.e. without the 8x8 or 16x16 equivalent of f, g and h. Furthermore:
37 // - There are no diagonal predictor modes, only DC, TM, VE and HE.
38 // - The DC mode has variants for macroblocks in the top row and/or left
39 // column, i.e. for macroblocks with mby == 0 || mbx == 0.
40 // - The VE and HE modes take only the column top or row left values; they do
41 // not smooth that top/left value with its neighbors.
42
43 // nPred is the number of predictor modes, not including the Top/Left versions
44 // of the DC predictor mode.
45 const nPred = 10
46
47 const (
48 predDC = iota
49 predTM
50 predVE
51 predHE
52 predRD
53 predVR
54 predLD
55 predVL
56 predHD
57 predHU
58 predDCTop
59 predDCLeft
60 predDCTopLeft
61 )
62
63 func checkTopLeftPred(mbx, mby int, p uint8) uint8 {
64 if p != predDC {
65 return p
66 }
67 if mbx == 0 {
68 if mby == 0 {
69 return predDCTopLeft
70 }
71 return predDCLeft
72 }
73 if mby == 0 {
74 return predDCTop
75 }
76 return predDC
77 }
78
79 var predFunc4 = [...]func(*Decoder, int, int){
80 predFunc4DC,
81 predFunc4TM,
82 predFunc4VE,
83 predFunc4HE,
84 predFunc4RD,
85 predFunc4VR,
86 predFunc4LD,
87 predFunc4VL,
88 predFunc4HD,
89 predFunc4HU,
90 nil,
91 nil,
92 nil,
93 }
94
95 var predFunc8 = [...]func(*Decoder, int, int){
96 predFunc8DC,
97 predFunc8TM,
98 predFunc8VE,
99 predFunc8HE,
100 nil,
101 nil,
102 nil,
103 nil,
104 nil,
105 nil,
106 predFunc8DCTop,
107 predFunc8DCLeft,
108 predFunc8DCTopLeft,
109 }
110
111 var predFunc16 = [...]func(*Decoder, int, int){
112 predFunc16DC,
113 predFunc16TM,
114 predFunc16VE,
115 predFunc16HE,
116 nil,
117 nil,
118 nil,
119 nil,
120 nil,
121 nil,
122 predFunc16DCTop,
123 predFunc16DCLeft,
124 predFunc16DCTopLeft,
125 }
126
127 func predFunc4DC(z *Decoder, y, x int) {
128 sum := uint32(4)
129 for i := 0; i < 4; i++ {
130 sum += uint32(z.ybr[y-1][x+i])
131 }
132 for j := 0; j < 4; j++ {
133 sum += uint32(z.ybr[y+j][x-1])
134 }
135 avg := uint8(sum / 8)
136 for j := 0; j < 4; j++ {
137 for i := 0; i < 4; i++ {
138 z.ybr[y+j][x+i] = avg
139 }
140 }
141 }
142
143 func predFunc4TM(z *Decoder, y, x int) {
144 delta0 := -int32(z.ybr[y-1][x-1])
145 for j := 0; j < 4; j++ {
146 delta1 := delta0 + int32(z.ybr[y+j][x-1])
147 for i := 0; i < 4; i++ {
148 delta2 := delta1 + int32(z.ybr[y-1][x+i])
149 z.ybr[y+j][x+i] = uint8(clip(delta2, 0, 255))
150 }
151 }
152 }
153
154 func predFunc4VE(z *Decoder, y, x int) {
155 a := int32(z.ybr[y-1][x-1])
156 b := int32(z.ybr[y-1][x+0])
157 c := int32(z.ybr[y-1][x+1])
158 d := int32(z.ybr[y-1][x+2])
159 e := int32(z.ybr[y-1][x+3])
160 f := int32(z.ybr[y-1][x+4])
161 abc := uint8((a + 2*b + c + 2) / 4)
162 bcd := uint8((b + 2*c + d + 2) / 4)
163 cde := uint8((c + 2*d + e + 2) / 4)
164 def := uint8((d + 2*e + f + 2) / 4)
165 for j := 0; j < 4; j++ {
166 z.ybr[y+j][x+0] = abc
167 z.ybr[y+j][x+1] = bcd
168 z.ybr[y+j][x+2] = cde
169 z.ybr[y+j][x+3] = def
170 }
171 }
172
173 func predFunc4HE(z *Decoder, y, x int) {
174 s := int32(z.ybr[y+3][x-1])
175 r := int32(z.ybr[y+2][x-1])
176 q := int32(z.ybr[y+1][x-1])
177 p := int32(z.ybr[y+0][x-1])
178 a := int32(z.ybr[y-1][x-1])
179 ssr := uint8((s + 2*s + r + 2) / 4)
180 srq := uint8((s + 2*r + q + 2) / 4)
181 rqp := uint8((r + 2*q + p + 2) / 4)
182 apq := uint8((a + 2*p + q + 2) / 4)
183 for i := 0; i < 4; i++ {
184 z.ybr[y+0][x+i] = apq
185 z.ybr[y+1][x+i] = rqp
186 z.ybr[y+2][x+i] = srq
187 z.ybr[y+3][x+i] = ssr
188 }
189 }
190
191 func predFunc4RD(z *Decoder, y, x int) {
192 s := int32(z.ybr[y+3][x-1])
193 r := int32(z.ybr[y+2][x-1])
194 q := int32(z.ybr[y+1][x-1])
195 p := int32(z.ybr[y+0][x-1])
196 a := int32(z.ybr[y-1][x-1])
197 b := int32(z.ybr[y-1][x+0])
198 c := int32(z.ybr[y-1][x+1])
199 d := int32(z.ybr[y-1][x+2])
200 e := int32(z.ybr[y-1][x+3])
201 srq := uint8((s + 2*r + q + 2) / 4)
202 rqp := uint8((r + 2*q + p + 2) / 4)
203 qpa := uint8((q + 2*p + a + 2) / 4)
204 pab := uint8((p + 2*a + b + 2) / 4)
205 abc := uint8((a + 2*b + c + 2) / 4)
206 bcd := uint8((b + 2*c + d + 2) / 4)
207 cde := uint8((c + 2*d + e + 2) / 4)
208 z.ybr[y+0][x+0] = pab
209 z.ybr[y+0][x+1] = abc
210 z.ybr[y+0][x+2] = bcd
211 z.ybr[y+0][x+3] = cde
212 z.ybr[y+1][x+0] = qpa
213 z.ybr[y+1][x+1] = pab
214 z.ybr[y+1][x+2] = abc
215 z.ybr[y+1][x+3] = bcd
216 z.ybr[y+2][x+0] = rqp
217 z.ybr[y+2][x+1] = qpa
218 z.ybr[y+2][x+2] = pab
219 z.ybr[y+2][x+3] = abc
220 z.ybr[y+3][x+0] = srq
221 z.ybr[y+3][x+1] = rqp
222 z.ybr[y+3][x+2] = qpa
223 z.ybr[y+3][x+3] = pab
224 }
225
226 func predFunc4VR(z *Decoder, y, x int) {
227 r := int32(z.ybr[y+2][x-1])
228 q := int32(z.ybr[y+1][x-1])
229 p := int32(z.ybr[y+0][x-1])
230 a := int32(z.ybr[y-1][x-1])
231 b := int32(z.ybr[y-1][x+0])
232 c := int32(z.ybr[y-1][x+1])
233 d := int32(z.ybr[y-1][x+2])
234 e := int32(z.ybr[y-1][x+3])
235 ab := uint8((a + b + 1) / 2)
236 bc := uint8((b + c + 1) / 2)
237 cd := uint8((c + d + 1) / 2)
238 de := uint8((d + e + 1) / 2)
239 rqp := uint8((r + 2*q + p + 2) / 4)
240 qpa := uint8((q + 2*p + a + 2) / 4)
241 pab := uint8((p + 2*a + b + 2) / 4)
242 abc := uint8((a + 2*b + c + 2) / 4)
243 bcd := uint8((b + 2*c + d + 2) / 4)
244 cde := uint8((c + 2*d + e + 2) / 4)
245 z.ybr[y+0][x+0] = ab
246 z.ybr[y+0][x+1] = bc
247 z.ybr[y+0][x+2] = cd
248 z.ybr[y+0][x+3] = de
249 z.ybr[y+1][x+0] = pab
250 z.ybr[y+1][x+1] = abc
251 z.ybr[y+1][x+2] = bcd
252 z.ybr[y+1][x+3] = cde
253 z.ybr[y+2][x+0] = qpa
254 z.ybr[y+2][x+1] = ab
255 z.ybr[y+2][x+2] = bc
256 z.ybr[y+2][x+3] = cd
257 z.ybr[y+3][x+0] = rqp
258 z.ybr[y+3][x+1] = pab
259 z.ybr[y+3][x+2] = abc
260 z.ybr[y+3][x+3] = bcd
261 }
262
263 func predFunc4LD(z *Decoder, y, x int) {
264 a := int32(z.ybr[y-1][x+0])
265 b := int32(z.ybr[y-1][x+1])
266 c := int32(z.ybr[y-1][x+2])
267 d := int32(z.ybr[y-1][x+3])
268 e := int32(z.ybr[y-1][x+4])
269 f := int32(z.ybr[y-1][x+5])
270 g := int32(z.ybr[y-1][x+6])
271 h := int32(z.ybr[y-1][x+7])
272 abc := uint8((a + 2*b + c + 2) / 4)
273 bcd := uint8((b + 2*c + d + 2) / 4)
274 cde := uint8((c + 2*d + e + 2) / 4)
275 def := uint8((d + 2*e + f + 2) / 4)
276 efg := uint8((e + 2*f + g + 2) / 4)
277 fgh := uint8((f + 2*g + h + 2) / 4)
278 ghh := uint8((g + 2*h + h + 2) / 4)
279 z.ybr[y+0][x+0] = abc
280 z.ybr[y+0][x+1] = bcd
281 z.ybr[y+0][x+2] = cde
282 z.ybr[y+0][x+3] = def
283 z.ybr[y+1][x+0] = bcd
284 z.ybr[y+1][x+1] = cde
285 z.ybr[y+1][x+2] = def
286 z.ybr[y+1][x+3] = efg
287 z.ybr[y+2][x+0] = cde
288 z.ybr[y+2][x+1] = def
289 z.ybr[y+2][x+2] = efg
290 z.ybr[y+2][x+3] = fgh
291 z.ybr[y+3][x+0] = def
292 z.ybr[y+3][x+1] = efg
293 z.ybr[y+3][x+2] = fgh
294 z.ybr[y+3][x+3] = ghh
295 }
296
297 func predFunc4VL(z *Decoder, y, x int) {
298 a := int32(z.ybr[y-1][x+0])
299 b := int32(z.ybr[y-1][x+1])
300 c := int32(z.ybr[y-1][x+2])
301 d := int32(z.ybr[y-1][x+3])
302 e := int32(z.ybr[y-1][x+4])
303 f := int32(z.ybr[y-1][x+5])
304 g := int32(z.ybr[y-1][x+6])
305 h := int32(z.ybr[y-1][x+7])
306 ab := uint8((a + b + 1) / 2)
307 bc := uint8((b + c + 1) / 2)
308 cd := uint8((c + d + 1) / 2)
309 de := uint8((d + e + 1) / 2)
310 abc := uint8((a + 2*b + c + 2) / 4)
311 bcd := uint8((b + 2*c + d + 2) / 4)
312 cde := uint8((c + 2*d + e + 2) / 4)
313 def := uint8((d + 2*e + f + 2) / 4)
314 efg := uint8((e + 2*f + g + 2) / 4)
315 fgh := uint8((f + 2*g + h + 2) / 4)
316 z.ybr[y+0][x+0] = ab
317 z.ybr[y+0][x+1] = bc
318 z.ybr[y+0][x+2] = cd
319 z.ybr[y+0][x+3] = de
320 z.ybr[y+1][x+0] = abc
321 z.ybr[y+1][x+1] = bcd
322 z.ybr[y+1][x+2] = cde
323 z.ybr[y+1][x+3] = def
324 z.ybr[y+2][x+0] = bc
325 z.ybr[y+2][x+1] = cd
326 z.ybr[y+2][x+2] = de
327 z.ybr[y+2][x+3] = efg
328 z.ybr[y+3][x+0] = bcd
329 z.ybr[y+3][x+1] = cde
330 z.ybr[y+3][x+2] = def
331 z.ybr[y+3][x+3] = fgh
332 }
333
334 func predFunc4HD(z *Decoder, y, x int) {
335 s := int32(z.ybr[y+3][x-1])
336 r := int32(z.ybr[y+2][x-1])
337 q := int32(z.ybr[y+1][x-1])
338 p := int32(z.ybr[y+0][x-1])
339 a := int32(z.ybr[y-1][x-1])
340 b := int32(z.ybr[y-1][x+0])
341 c := int32(z.ybr[y-1][x+1])
342 d := int32(z.ybr[y-1][x+2])
343 sr := uint8((s + r + 1) / 2)
344 rq := uint8((r + q + 1) / 2)
345 qp := uint8((q + p + 1) / 2)
346 pa := uint8((p + a + 1) / 2)
347 srq := uint8((s + 2*r + q + 2) / 4)
348 rqp := uint8((r + 2*q + p + 2) / 4)
349 qpa := uint8((q + 2*p + a + 2) / 4)
350 pab := uint8((p + 2*a + b + 2) / 4)
351 abc := uint8((a + 2*b + c + 2) / 4)
352 bcd := uint8((b + 2*c + d + 2) / 4)
353 z.ybr[y+0][x+0] = pa
354 z.ybr[y+0][x+1] = pab
355 z.ybr[y+0][x+2] = abc
356 z.ybr[y+0][x+3] = bcd
357 z.ybr[y+1][x+0] = qp
358 z.ybr[y+1][x+1] = qpa
359 z.ybr[y+1][x+2] = pa
360 z.ybr[y+1][x+3] = pab
361 z.ybr[y+2][x+0] = rq
362 z.ybr[y+2][x+1] = rqp
363 z.ybr[y+2][x+2] = qp
364 z.ybr[y+2][x+3] = qpa
365 z.ybr[y+3][x+0] = sr
366 z.ybr[y+3][x+1] = srq
367 z.ybr[y+3][x+2] = rq
368 z.ybr[y+3][x+3] = rqp
369 }
370
371 func predFunc4HU(z *Decoder, y, x int) {
372 s := int32(z.ybr[y+3][x-1])
373 r := int32(z.ybr[y+2][x-1])
374 q := int32(z.ybr[y+1][x-1])
375 p := int32(z.ybr[y+0][x-1])
376 pq := uint8((p + q + 1) / 2)
377 qr := uint8((q + r + 1) / 2)
378 rs := uint8((r + s + 1) / 2)
379 pqr := uint8((p + 2*q + r + 2) / 4)
380 qrs := uint8((q + 2*r + s + 2) / 4)
381 rss := uint8((r + 2*s + s + 2) / 4)
382 sss := uint8(s)
383 z.ybr[y+0][x+0] = pq
384 z.ybr[y+0][x+1] = pqr
385 z.ybr[y+0][x+2] = qr
386 z.ybr[y+0][x+3] = qrs
387 z.ybr[y+1][x+0] = qr
388 z.ybr[y+1][x+1] = qrs
389 z.ybr[y+1][x+2] = rs
390 z.ybr[y+1][x+3] = rss
391 z.ybr[y+2][x+0] = rs
392 z.ybr[y+2][x+1] = rss
393 z.ybr[y+2][x+2] = sss
394 z.ybr[y+2][x+3] = sss
395 z.ybr[y+3][x+0] = sss
396 z.ybr[y+3][x+1] = sss
397 z.ybr[y+3][x+2] = sss
398 z.ybr[y+3][x+3] = sss
399 }
400
401 func predFunc8DC(z *Decoder, y, x int) {
402 sum := uint32(8)
403 for i := 0; i < 8; i++ {
404 sum += uint32(z.ybr[y-1][x+i])
405 }
406 for j := 0; j < 8; j++ {
407 sum += uint32(z.ybr[y+j][x-1])
408 }
409 avg := uint8(sum / 16)
410 for j := 0; j < 8; j++ {
411 for i := 0; i < 8; i++ {
412 z.ybr[y+j][x+i] = avg
413 }
414 }
415 }
416
417 func predFunc8TM(z *Decoder, y, x int) {
418 delta0 := -int32(z.ybr[y-1][x-1])
419 for j := 0; j < 8; j++ {
420 delta1 := delta0 + int32(z.ybr[y+j][x-1])
421 for i := 0; i < 8; i++ {
422 delta2 := delta1 + int32(z.ybr[y-1][x+i])
423 z.ybr[y+j][x+i] = uint8(clip(delta2, 0, 255))
424 }
425 }
426 }
427
428 func predFunc8VE(z *Decoder, y, x int) {
429 for j := 0; j < 8; j++ {
430 for i := 0; i < 8; i++ {
431 z.ybr[y+j][x+i] = z.ybr[y-1][x+i]
432 }
433 }
434 }
435
436 func predFunc8HE(z *Decoder, y, x int) {
437 for j := 0; j < 8; j++ {
438 for i := 0; i < 8; i++ {
439 z.ybr[y+j][x+i] = z.ybr[y+j][x-1]
440 }
441 }
442 }
443
444 func predFunc8DCTop(z *Decoder, y, x int) {
445 sum := uint32(4)
446 for j := 0; j < 8; j++ {
447 sum += uint32(z.ybr[y+j][x-1])
448 }
449 avg := uint8(sum / 8)
450 for j := 0; j < 8; j++ {
451 for i := 0; i < 8; i++ {
452 z.ybr[y+j][x+i] = avg
453 }
454 }
455 }
456
457 func predFunc8DCLeft(z *Decoder, y, x int) {
458 sum := uint32(4)
459 for i := 0; i < 8; i++ {
460 sum += uint32(z.ybr[y-1][x+i])
461 }
462 avg := uint8(sum / 8)
463 for j := 0; j < 8; j++ {
464 for i := 0; i < 8; i++ {
465 z.ybr[y+j][x+i] = avg
466 }
467 }
468 }
469
470 func predFunc8DCTopLeft(z *Decoder, y, x int) {
471 for j := 0; j < 8; j++ {
472 for i := 0; i < 8; i++ {
473 z.ybr[y+j][x+i] = 0x80
474 }
475 }
476 }
477
478 func predFunc16DC(z *Decoder, y, x int) {
479 sum := uint32(16)
480 for i := 0; i < 16; i++ {
481 sum += uint32(z.ybr[y-1][x+i])
482 }
483 for j := 0; j < 16; j++ {
484 sum += uint32(z.ybr[y+j][x-1])
485 }
486 avg := uint8(sum / 32)
487 for j := 0; j < 16; j++ {
488 for i := 0; i < 16; i++ {
489 z.ybr[y+j][x+i] = avg
490 }
491 }
492 }
493
494 func predFunc16TM(z *Decoder, y, x int) {
495 delta0 := -int32(z.ybr[y-1][x-1])
496 for j := 0; j < 16; j++ {
497 delta1 := delta0 + int32(z.ybr[y+j][x-1])
498 for i := 0; i < 16; i++ {
499 delta2 := delta1 + int32(z.ybr[y-1][x+i])
500 z.ybr[y+j][x+i] = uint8(clip(delta2, 0, 255))
501 }
502 }
503 }
504
505 func predFunc16VE(z *Decoder, y, x int) {
506 for j := 0; j < 16; j++ {
507 for i := 0; i < 16; i++ {
508 z.ybr[y+j][x+i] = z.ybr[y-1][x+i]
509 }
510 }
511 }
512
513 func predFunc16HE(z *Decoder, y, x int) {
514 for j := 0; j < 16; j++ {
515 for i := 0; i < 16; i++ {
516 z.ybr[y+j][x+i] = z.ybr[y+j][x-1]
517 }
518 }
519 }
520
521 func predFunc16DCTop(z *Decoder, y, x int) {
522 sum := uint32(8)
523 for j := 0; j < 16; j++ {
524 sum += uint32(z.ybr[y+j][x-1])
525 }
526 avg := uint8(sum / 16)
527 for j := 0; j < 16; j++ {
528 for i := 0; i < 16; i++ {
529 z.ybr[y+j][x+i] = avg
530 }
531 }
532 }
533
534 func predFunc16DCLeft(z *Decoder, y, x int) {
535 sum := uint32(8)
536 for i := 0; i < 16; i++ {
537 sum += uint32(z.ybr[y-1][x+i])
538 }
539 avg := uint8(sum / 16)
540 for j := 0; j < 16; j++ {
541 for i := 0; i < 16; i++ {
542 z.ybr[y+j][x+i] = avg
543 }
544 }
545 }
546
547 func predFunc16DCTopLeft(z *Decoder, y, x int) {
548 for j := 0; j < 16; j++ {
549 for i := 0; i < 16; i++ {
550 z.ybr[y+j][x+i] = 0x80
551 }
552 }
553 }