// Copyright 2014 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 vp8
 
 // filter2 modifies a 2-pixel wide or 2-pixel high band along an edge.
 func filter2(pix []byte, level, index, iStep, jStep int) {
 	for n := 16; n > 0; n, index = n-1, index+iStep {
 		p1 := int(pix[index-2*jStep])
 		p0 := int(pix[index-1*jStep])
 		q0 := int(pix[index+0*jStep])
 		q1 := int(pix[index+1*jStep])
 		if abs(p0-q0)<<1+abs(p1-q1)>>1 > level {
 			continue
 		}
 		a := 3*(q0-p0) + clamp127(p1-q1)
 		a1 := clamp15((a + 4) >> 3)
 		a2 := clamp15((a + 3) >> 3)
 		pix[index-1*jStep] = clamp255(p0 + a2)
 		pix[index+0*jStep] = clamp255(q0 - a1)
 	}
 }
 
 // filter246 modifies a 2-, 4- or 6-pixel wide or high band along an edge.
 func filter246(pix []byte, n, level, ilevel, hlevel, index, iStep, jStep int, fourNotSix bool) {
 	for ; n > 0; n, index = n-1, index+iStep {
 		p3 := int(pix[index-4*jStep])
 		p2 := int(pix[index-3*jStep])
 		p1 := int(pix[index-2*jStep])
 		p0 := int(pix[index-1*jStep])
 		q0 := int(pix[index+0*jStep])
 		q1 := int(pix[index+1*jStep])
 		q2 := int(pix[index+2*jStep])
 		q3 := int(pix[index+3*jStep])
 		if abs(p0-q0)<<1+abs(p1-q1)>>1 > level {
 			continue
 		}
 		if abs(p3-p2) > ilevel ||
 			abs(p2-p1) > ilevel ||
 			abs(p1-p0) > ilevel ||
 			abs(q1-q0) > ilevel ||
 			abs(q2-q1) > ilevel ||
 			abs(q3-q2) > ilevel {
 			continue
 		}
 		if abs(p1-p0) > hlevel || abs(q1-q0) > hlevel {
 			// Filter 2 pixels.
 			a := 3*(q0-p0) + clamp127(p1-q1)
 			a1 := clamp15((a + 4) >> 3)
 			a2 := clamp15((a + 3) >> 3)
 			pix[index-1*jStep] = clamp255(p0 + a2)
 			pix[index+0*jStep] = clamp255(q0 - a1)
 		} else if fourNotSix {
 			// Filter 4 pixels.
 			a := 3 * (q0 - p0)
 			a1 := clamp15((a + 4) >> 3)
 			a2 := clamp15((a + 3) >> 3)
 			a3 := (a1 + 1) >> 1
 			pix[index-2*jStep] = clamp255(p1 + a3)
 			pix[index-1*jStep] = clamp255(p0 + a2)
 			pix[index+0*jStep] = clamp255(q0 - a1)
 			pix[index+1*jStep] = clamp255(q1 - a3)
 		} else {
 			// Filter 6 pixels.
 			a := clamp127(3*(q0-p0) + clamp127(p1-q1))
 			a1 := (27*a + 63) >> 7
 			a2 := (18*a + 63) >> 7
 			a3 := (9*a + 63) >> 7
 			pix[index-3*jStep] = clamp255(p2 + a3)
 			pix[index-2*jStep] = clamp255(p1 + a2)
 			pix[index-1*jStep] = clamp255(p0 + a1)
 			pix[index+0*jStep] = clamp255(q0 - a1)
 			pix[index+1*jStep] = clamp255(q1 - a2)
 			pix[index+2*jStep] = clamp255(q2 - a3)
 		}
 	}
 }
 
 // simpleFilter implements the simple filter, as specified in section 15.2.
 func (d *Decoder) simpleFilter() {
 	for mby := 0; mby < d.mbh; mby++ {
 		for mbx := 0; mbx < d.mbw; mbx++ {
 			f := d.perMBFilterParams[d.mbw*mby+mbx]
 			if f.level == 0 {
 				continue
 			}
 			l := int(f.level)
 			yIndex := (mby*d.img.YStride + mbx) * 16
 			if mbx > 0 {
 				filter2(d.img.Y, l+4, yIndex, d.img.YStride, 1)
 			}
 			if f.inner {
 				filter2(d.img.Y, l, yIndex+0x4, d.img.YStride, 1)
 				filter2(d.img.Y, l, yIndex+0x8, d.img.YStride, 1)
 				filter2(d.img.Y, l, yIndex+0xc, d.img.YStride, 1)
 			}
 			if mby > 0 {
 				filter2(d.img.Y, l+4, yIndex, 1, d.img.YStride)
 			}
 			if f.inner {
 				filter2(d.img.Y, l, yIndex+d.img.YStride*0x4, 1, d.img.YStride)
 				filter2(d.img.Y, l, yIndex+d.img.YStride*0x8, 1, d.img.YStride)
 				filter2(d.img.Y, l, yIndex+d.img.YStride*0xc, 1, d.img.YStride)
 			}
 		}
 	}
 }
 
 // normalFilter implements the normal filter, as specified in section 15.3.
 func (d *Decoder) normalFilter() {
 	for mby := 0; mby < d.mbh; mby++ {
 		for mbx := 0; mbx < d.mbw; mbx++ {
 			f := d.perMBFilterParams[d.mbw*mby+mbx]
 			if f.level == 0 {
 				continue
 			}
 			l, il, hl := int(f.level), int(f.ilevel), int(f.hlevel)
 			yIndex := (mby*d.img.YStride + mbx) * 16
 			cIndex := (mby*d.img.CStride + mbx) * 8
 			if mbx > 0 {
 				filter246(d.img.Y, 16, l+4, il, hl, yIndex, d.img.YStride, 1, false)
 				filter246(d.img.Cb, 8, l+4, il, hl, cIndex, d.img.CStride, 1, false)
 				filter246(d.img.Cr, 8, l+4, il, hl, cIndex, d.img.CStride, 1, false)
 			}
 			if f.inner {
 				filter246(d.img.Y, 16, l, il, hl, yIndex+0x4, d.img.YStride, 1, true)
 				filter246(d.img.Y, 16, l, il, hl, yIndex+0x8, d.img.YStride, 1, true)
 				filter246(d.img.Y, 16, l, il, hl, yIndex+0xc, d.img.YStride, 1, true)
 				filter246(d.img.Cb, 8, l, il, hl, cIndex+0x4, d.img.CStride, 1, true)
 				filter246(d.img.Cr, 8, l, il, hl, cIndex+0x4, d.img.CStride, 1, true)
 			}
 			if mby > 0 {
 				filter246(d.img.Y, 16, l+4, il, hl, yIndex, 1, d.img.YStride, false)
 				filter246(d.img.Cb, 8, l+4, il, hl, cIndex, 1, d.img.CStride, false)
 				filter246(d.img.Cr, 8, l+4, il, hl, cIndex, 1, d.img.CStride, false)
 			}
 			if f.inner {
 				filter246(d.img.Y, 16, l, il, hl, yIndex+d.img.YStride*0x4, 1, d.img.YStride, true)
 				filter246(d.img.Y, 16, l, il, hl, yIndex+d.img.YStride*0x8, 1, d.img.YStride, true)
 				filter246(d.img.Y, 16, l, il, hl, yIndex+d.img.YStride*0xc, 1, d.img.YStride, true)
 				filter246(d.img.Cb, 8, l, il, hl, cIndex+d.img.CStride*0x4, 1, d.img.CStride, true)
 				filter246(d.img.Cr, 8, l, il, hl, cIndex+d.img.CStride*0x4, 1, d.img.CStride, true)
 			}
 		}
 	}
 }
 
 // filterParam holds the loop filter parameters for a macroblock.
 type filterParam struct {
 	// The first three fields are thresholds used by the loop filter to smooth
 	// over the edges and interior of a macroblock. level is used by both the
 	// simple and normal filters. The inner level and high edge variance level
 	// are only used by the normal filter.
 	level, ilevel, hlevel uint8
 	// inner is whether the inner loop filter cannot be optimized out as a
 	// no-op for this particular macroblock.
 	inner bool
 }
 
 // computeFilterParams computes the loop filter parameters, as specified in
 // section 15.4.
 func (d *Decoder) computeFilterParams() {
 	for i := range d.filterParams {
 		baseLevel := d.filterHeader.level
 		if d.segmentHeader.useSegment {
 			baseLevel = d.segmentHeader.filterStrength[i]
 			if d.segmentHeader.relativeDelta {
 				baseLevel += d.filterHeader.level
 			}
 		}
 
 		for j := range d.filterParams[i] {
 			p := &d.filterParams[i][j]
 			p.inner = j != 0
 			level := baseLevel
 			if d.filterHeader.useLFDelta {
 				// The libwebp C code has a "TODO: only CURRENT is handled for now."
 				level += d.filterHeader.refLFDelta[0]
 				if j != 0 {
 					level += d.filterHeader.modeLFDelta[0]
 				}
 			}
 			if level <= 0 {
 				p.level = 0
 				continue
 			}
 			if level > 63 {
 				level = 63
 			}
 			ilevel := level
 			if d.filterHeader.sharpness > 0 {
 				if d.filterHeader.sharpness > 4 {
 					ilevel >>= 2
 				} else {
 					ilevel >>= 1
 				}
 				if x := int8(9 - d.filterHeader.sharpness); ilevel > x {
 					ilevel = x
 				}
 			}
 			if ilevel < 1 {
 				ilevel = 1
 			}
 			p.ilevel = uint8(ilevel)
 			p.level = uint8(2*level + ilevel)
 			if d.frameHeader.KeyFrame {
 				if level < 15 {
 					p.hlevel = 0
 				} else if level < 40 {
 					p.hlevel = 1
 				} else {
 					p.hlevel = 2
 				}
 			} else {
 				if level < 15 {
 					p.hlevel = 0
 				} else if level < 20 {
 					p.hlevel = 1
 				} else if level < 40 {
 					p.hlevel = 2
 				} else {
 					p.hlevel = 3
 				}
 			}
 		}
 	}
 }
 
 // intSize is either 32 or 64.
 const intSize = 32 << (^uint(0) >> 63)
 
 func abs(x int) int {
 	// m := -1 if x < 0. m := 0 otherwise.
 	m := x >> (intSize - 1)
 
 	// In two's complement representation, the negative number
 	// of any number (except the smallest one) can be computed
 	// by flipping all the bits and add 1. This is faster than
 	// code with a branch.
 	// See Hacker's Delight, section 2-4.
 	return (x ^ m) - m
 }
 
 func clamp15(x int) int {
 	if x < -16 {
 		return -16
 	}
 	if x > 15 {
 		return 15
 	}
 	return x
 }
 
 func clamp127(x int) int {
 	if x < -128 {
 		return -128
 	}
 	if x > 127 {
 		return 127
 	}
 	return x
 }
 
 func clamp255(x int) uint8 {
 	if x < 0 {
 		return 0
 	}
 	if x > 255 {
 		return 255
 	}
 	return uint8(x)
 }