/vp8/predfunc.go

https://code.google.com/p/vp8-go/ · Go · 553 lines · 481 code · 32 blank · 40 comment · 52 complexity · debad7dca3c3081b9047caa5e1b1b54b MD5 · raw file

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