зеркало из https://github.com/golang/image.git
274 строки
7.6 KiB
Go
274 строки
7.6 KiB
Go
// 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)
|
|
}
|