aw/go-resize
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ca1e14ffbd
go-resize/converter.go

439 lines
12 KiB
Go
Raw Normal View History

Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
/*
Copyright (c) 2012, Jan Schlicht <jan.schlicht@gmail.com>
Permission to use, copy, modify, and/or distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright notice
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
*/
package resize
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
import "image"
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
// Keep value in [0,255] range.
func clampUint8(in int32) uint8 {
Fix typos.
2015-03-18 20:19:43 +01:00
// casting a negative int to an uint will result in an overflown
// large uint. this behavior will be exploited here and in other functions
// to achieve a higher performance.
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
if uint32(in) < 256 {
return uint8(in)
Replicate border instead of using a constant Constant border could lead to wrong values alpha values with certain configurations.
2012-12-10 19:27:21 +01:00
}
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
if in > 255 {
return 255
}
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
return 0
Replicate border instead of using a constant Constant border could lead to wrong values alpha values with certain configurations.
2012-12-10 19:27:21 +01:00
}
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
// Keep value in [0,65535] range.
func clampUint16(in int64) uint16 {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
if uint64(in) < 65536 {
return uint16(in)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
if in > 65535 {
return 65535
}
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
return 0
Replicate border instead of using a constant Constant border could lead to wrong values alpha values with certain configurations.
2012-12-10 19:27:21 +01:00
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
func resizeGeneric(in image.Image, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Change ordering
2012-12-11 19:57:34 +01:00
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var rgba [4]int64
var sum int64
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for i := 0; i < filterLength; i++ {
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi < 0:
xi = 0
case xi >= maxX:
xi = maxX
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
r, g, b, a := in.At(xi+in.Bounds().Min.X, x+in.Bounds().Min.Y).RGBA()
Reverse alpha-premultiplication for image.RGBA, image.RGBA64 and generic images types.
2015-05-12 15:19:11 +02:00
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
rgba[0] += int64(coeff) * int64(r)
rgba[1] += int64(coeff) * int64(g)
rgba[2] += int64(coeff) * int64(b)
rgba[3] += int64(coeff) * int64(a)
sum += int64(coeff)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
offset := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value := clampUint16(rgba[0] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
out.Pix[offset+0] = uint8(value >> 8)
out.Pix[offset+1] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[1] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
out.Pix[offset+2] = uint8(value >> 8)
out.Pix[offset+3] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[2] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
out.Pix[offset+4] = uint8(value >> 8)
out.Pix[offset+5] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[3] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
out.Pix[offset+6] = uint8(value >> 8)
out.Pix[offset+7] = uint8(value)
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
func resizeRGBA(in *image.RGBA, out *image.RGBA, scale float64, coeffs []int16, offset []int, filterLength int) {
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix parallel computation.
2014-08-20 21:12:39 +02:00
row := in.Pix[x*in.Stride:]
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var rgba [4]int32
var sum int32
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for i := 0; i < filterLength; i++ {
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
case uint(xi) < uint(maxX):
xi *= 4
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi >= maxX:
xi = 4 * maxX
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
default:
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
xi = 0
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
}
Reverse alpha-premultiplication for image.RGBA, image.RGBA64 and generic images types.
2015-05-12 15:19:11 +02:00
Reverse alpha premultiplication
2016-01-07 16:39:12 +01:00
rgba[0] += int32(coeff) * int32(row[xi+0])
rgba[1] += int32(coeff) * int32(row[xi+1])
rgba[2] += int32(coeff) * int32(row[xi+2])
rgba[3] += int32(coeff) * int32(row[xi+3])
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
sum += int32(coeff)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*4
Oops
2016-01-07 17:38:35 +01:00
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
out.Pix[xo+0] = clampUint8(rgba[0] / sum)
out.Pix[xo+1] = clampUint8(rgba[1] / sum)
out.Pix[xo+2] = clampUint8(rgba[2] / sum)
out.Pix[xo+3] = clampUint8(rgba[3] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
func resizeNRGBA(in *image.NRGBA, out *image.RGBA, scale float64, coeffs []int16, offset []int, filterLength int) {
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
newBounds := out.Bounds()
maxX := in.Bounds().Dx() - 1
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
row := in.Pix[x*in.Stride:]
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var rgba [4]int32
var sum int32
start := offset[y]
ci := y * filterLength
for i := 0; i < filterLength; i++ {
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
case uint(xi) < uint(maxX):
xi *= 4
case xi >= maxX:
xi = 4 * maxX
default:
xi = 0
}
Reverse alpha premultiplication
2016-01-07 16:39:12 +01:00
// Forward alpha-premultiplication
a := int32(row[xi+3])
Fix alpha pre-multiplication. The alpha pre-multiplication was applied to an aggregate value an not to the color value. This could cause wrong colors for images with an alpha channel. Fixes #47.
2016-07-24 22:39:20 +02:00
r := int32(row[xi+0]) * a
r /= 0xff
g := int32(row[xi+1]) * a
g /= 0xff
b := int32(row[xi+2]) * a
b /= 0xff
rgba[0] += int32(coeff) * r
rgba[1] += int32(coeff) * g
rgba[2] += int32(coeff) * b
rgba[3] += int32(coeff) * a
sum += int32(coeff)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
}
}
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*4
Oops
2016-01-07 17:38:35 +01:00
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
out.Pix[xo+0] = clampUint8(rgba[0] / sum)
out.Pix[xo+1] = clampUint8(rgba[1] / sum)
out.Pix[xo+2] = clampUint8(rgba[2] / sum)
out.Pix[xo+3] = clampUint8(rgba[3] / sum)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
}
}
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
func resizeRGBA64(in *image.RGBA64, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
newBounds := out.Bounds()
maxX := in.Bounds().Dx() - 1
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
row := in.Pix[x*in.Stride:]
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var rgba [4]int64
var sum int64
start := offset[y]
ci := y * filterLength
for i := 0; i < filterLength; i++ {
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
case uint(xi) < uint(maxX):
xi *= 8
case xi >= maxX:
xi = 8 * maxX
default:
xi = 0
}
Reverse alpha-premultiplication for image.RGBA, image.RGBA64 and generic images types.
2015-05-12 15:19:11 +02:00
Reverse alpha premultiplication
2016-01-07 16:39:12 +01:00
rgba[0] += int64(coeff) * (int64(row[xi+0])<<8 | int64(row[xi+1]))
rgba[1] += int64(coeff) * (int64(row[xi+2])<<8 | int64(row[xi+3]))
rgba[2] += int64(coeff) * (int64(row[xi+4])<<8 | int64(row[xi+5]))
rgba[3] += int64(coeff) * (int64(row[xi+6])<<8 | int64(row[xi+7]))
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
sum += int64(coeff)
}
}
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value := clampUint16(rgba[0] / sum)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
out.Pix[xo+0] = uint8(value >> 8)
out.Pix[xo+1] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[1] / sum)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
out.Pix[xo+2] = uint8(value >> 8)
out.Pix[xo+3] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[2] / sum)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
out.Pix[xo+4] = uint8(value >> 8)
out.Pix[xo+5] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[3] / sum)
Return NRGBA images. Resizing images with alpha channels is easier for NRGBA, NRGBA64 image types. Support for these is added by providing the necessary resize functions.
2015-03-25 18:38:23 +01:00
out.Pix[xo+6] = uint8(value >> 8)
out.Pix[xo+7] = uint8(value)
}
}
}
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
func resizeNRGBA64(in *image.NRGBA64, out *image.RGBA64, scale float64, coeffs []int32, offset []int, filterLength int) {
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix parallel computation.
2014-08-20 21:12:39 +02:00
row := in.Pix[x*in.Stride:]
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var rgba [4]int64
var sum int64
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for i := 0; i < filterLength; i++ {
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
case uint(xi) < uint(maxX):
xi *= 8
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi >= maxX:
xi = 8 * maxX
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
default:
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
xi = 0
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
}
Oops
2016-01-07 17:38:35 +01:00
Separate color assignment and alpha pre-multiplication.
2016-01-09 12:18:50 +01:00
// Forward alpha-premultiplication
a := int64(uint16(row[xi+6])<<8 | uint16(row[xi+7]))
Fix alpha pre-multiplication. The alpha pre-multiplication was applied to an aggregate value an not to the color value. This could cause wrong colors for images with an alpha channel. Fixes #47.
2016-07-24 22:39:20 +02:00
r := int64(uint16(row[xi+0])<<8|uint16(row[xi+1])) * a
r /= 0xffff
g := int64(uint16(row[xi+2])<<8|uint16(row[xi+3])) * a
g /= 0xffff
b := int64(uint16(row[xi+4])<<8|uint16(row[xi+5])) * a
b /= 0xffff
rgba[0] += int64(coeff) * r
rgba[1] += int64(coeff) * g
rgba[2] += int64(coeff) * b
rgba[3] += int64(coeff) * a
sum += int64(coeff)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*8
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value := clampUint16(rgba[0] / sum)
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
out.Pix[xo+0] = uint8(value >> 8)
out.Pix[xo+1] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[1] / sum)
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
out.Pix[xo+2] = uint8(value >> 8)
out.Pix[xo+3] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[2] / sum)
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
out.Pix[xo+4] = uint8(value >> 8)
out.Pix[xo+5] = uint8(value)
Use RGBA, RGBA64 image types as output. These image types use premultiplied alpha values which are also used during the interpolation. If we'd use NRGBA, NRGBA64 as output, we'd have to reverse the premultiplication.
2016-01-07 21:25:38 +01:00
value = clampUint16(rgba[3] / sum)
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
out.Pix[xo+6] = uint8(value >> 8)
out.Pix[xo+7] = uint8(value)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
func resizeGray(in *image.Gray, out *image.Gray, scale float64, coeffs []int16, offset []int, filterLength int) {
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
row := in.Pix[(x-newBounds.Min.X)*in.Stride:]
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var gray int32
var sum int32
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for i := 0; i < filterLength; i++ {
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi < 0:
xi = 0
case xi >= maxX:
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
xi = maxX
}
gray += int32(coeff) * int32(row[xi])
sum += int32(coeff)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
offset := (y-newBounds.Min.Y)*out.Stride + (x - newBounds.Min.X)
out.Pix[offset] = clampUint8(gray / sum)
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
func resizeGray16(in *image.Gray16, out *image.Gray16, scale float64, coeffs []int32, offset []int, filterLength int) {
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix parallel computation.
2014-08-20 21:12:39 +02:00
row := in.Pix[x*in.Stride:]
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var gray int64
var sum int64
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
for i := 0; i < filterLength; i++ {
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
case uint(xi) < uint(maxX):
xi *= 2
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi >= maxX:
xi = 2 * maxX
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
default:
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
xi = 0
Pre-calculate start offset, optimize bound check Increased performance by 30% for RGBA and 45% for Gray images, minor performance increase for 16-bit images. The start offset calculated by createWeights are stored in a slice and passed to the resize functions to prevent duplication of effort.
2014-07-29 22:53:35 +02:00
}
gray += int64(coeff) * int64(uint16(row[xi+0])<<8|uint16(row[xi+1]))
sum += int64(coeff)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
offset := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*2
value := clampUint16(gray / sum)
out.Pix[offset+0] = uint8(value >> 8)
out.Pix[offset+1] = uint8(value)
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
func resizeYCbCr(in *ycc, out *ycc, scale float64, coeffs []int16, offset []int, filterLength int) {
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix parallel computation.
2014-08-20 21:12:39 +02:00
row := in.Pix[x*in.Stride:]
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var p [3]int32
var sum int32
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for i := 0; i < filterLength; i++ {
coeff := coeffs[ci+i]
if coeff != 0 {
xi := start + i
switch {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
case uint(xi) < uint(maxX):
xi *= 3
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi >= maxX:
xi = 3 * maxX
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
default:
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
xi = 0
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
}
p[0] += int32(coeff) * int32(row[xi+0])
p[1] += int32(coeff) * int32(row[xi+1])
p[2] += int32(coeff) * int32(row[xi+2])
sum += int32(coeff)
}
}
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
out.Pix[xo+0] = clampUint8(p[0] / sum)
out.Pix[xo+1] = clampUint8(p[1] / sum)
out.Pix[xo+2] = clampUint8(p[2] / sum)
}
}
}
func nearestYCbCr(in *ycc, out *ycc, scale float64, coeffs []bool, offset []int, filterLength int) {
newBounds := out.Bounds()
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
maxX := in.Bounds().Dx() - 1
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for x := newBounds.Min.X; x < newBounds.Max.X; x++ {
Fix parallel computation.
2014-08-20 21:12:39 +02:00
row := in.Pix[x*in.Stride:]
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for y := newBounds.Min.Y; y < newBounds.Max.Y; y++ {
var p [3]float32
var sum float32
Fix parallel computation.
2014-08-20 21:12:39 +02:00
start := offset[y]
Resolve image artifacts due to wrong coefficient index lookup.
2014-09-15 11:50:59 +02:00
ci := y * filterLength
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
for i := 0; i < filterLength; i++ {
if coeffs[ci+i] {
xi := start + i
switch {
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
case uint(xi) < uint(maxX):
xi *= 3
Fix wrong boundary calculation (bug #17) This fix doesn't currently work concurrently. This will be fixed in another commit.
2014-08-20 20:54:59 +02:00
case xi >= maxX:
xi = 3 * maxX
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
default:
Optimize bound checks. Optimizing the bound checks resulted in an overall 14% increase in conversion performance.
2015-03-15 22:44:39 +01:00
xi = 0
Optimize YCbCr image resize
2014-07-30 08:08:58 +02:00
}
p[0] += float32(row[xi+0])
p[1] += float32(row[xi+1])
p[2] += float32(row[xi+2])
sum++
}
}
xo := (y-newBounds.Min.Y)*out.Stride + (x-newBounds.Min.X)*3
out.Pix[xo+0] = floatToUint8(p[0] / sum)
out.Pix[xo+1] = floatToUint8(p[1] / sum)
out.Pix[xo+2] = floatToUint8(p[2] / sum)
Optimize data-locality for a huge increase in processing speed. This is a complete rewrite! The tight scaling loop needs data locality for optimal performance. The old version used lots of pointer redirections to access image data which was bad for data locality. By providing the complete loop for each image type, this problem is solved. Unfortunately this increases code duplication but the result should be worth it: I could measure a ~6x speed-up for certain test cases!
2014-07-19 13:19:31 +02:00
}
}
Speed up computation: Try to avoid Image.At() as much as possible -> specialized color access for some image types
2012-09-21 20:02:25 +02:00
}
Reference in New Issue Copy Permalink