| // Copyright (C) 2016 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package image |
| |
| import ( |
| "bytes" |
| |
| "android.googlesource.com/platform/tools/gpu/framework/binary/endian" |
| "android.googlesource.com/platform/tools/gpu/framework/device" |
| "android.googlesource.com/platform/tools/gpu/framework/math/sint" |
| "android.googlesource.com/platform/tools/gpu/framework/math/u64" |
| "android.googlesource.com/platform/tools/gpu/gapid/image" |
| ) |
| |
| func init() { |
| image.RegisterConverter(image.ETC2_RGB8(), image.RGBA(), func(src []byte, width, height int) ([]byte, error) { |
| return decodeETC(src, width, height, false) |
| }) |
| image.RegisterConverter(image.ETC2_RGBA8_EAC(), image.RGBA(), func(src []byte, width, height int) ([]byte, error) { |
| return decodeETC(src, width, height, true) |
| }) |
| } |
| |
| func decodeETC(src []byte, width, height int, hasAlpha bool) ([]byte, error) { |
| dst := make([]byte, width*height*4) |
| |
| block_width := sint.Max((width+3)/4, 1) |
| block_height := sint.Max((height+3)/4, 1) |
| |
| const ( |
| R = 0 |
| G = 1 |
| B = 2 |
| ) |
| c := [4][3]int{} |
| codes := [2][4]int{} |
| modTbl0 := [8][4]int{ // mode 0 (ETC1) |
| {2, 8, -2, -8}, |
| {5, 17, -5, -17}, |
| {9, 29, -9, -29}, |
| {13, 42, -13, -42}, |
| {18, 60, -18, -60}, |
| {24, 80, -24, -80}, |
| {33, 106, -33, -106}, |
| {47, 183, -47, -183}, |
| } |
| modTbl1 := [8]int{3, 6, 11, 16, 23, 32, 41, 64} |
| diffTbl := [8]int{0, 1, 2, 3, -4, -3, -2, -1} |
| flipTbl := [2][16]int{ |
| {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1}, |
| {0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1}, |
| } |
| alphaModTbl := [16][8]int{ |
| {-3, -6, -9, -15, 2, 5, 8, 14}, |
| {-3, -7, -10, -13, 2, 6, 9, 12}, |
| {-2, -5, -8, -13, 1, 4, 7, 12}, |
| {-2, -4, -6, -13, 1, 3, 5, 12}, |
| {-3, -6, -8, -12, 2, 5, 7, 11}, |
| {-3, -7, -9, -11, 2, 6, 8, 10}, |
| {-4, -7, -8, -11, 3, 6, 7, 10}, |
| {-3, -5, -8, -11, 2, 4, 7, 10}, |
| {-2, -6, -8, -10, 1, 5, 7, 9}, |
| {-2, -5, -8, -10, 1, 4, 7, 9}, |
| {-2, -4, -8, -10, 1, 3, 7, 9}, |
| {-2, -5, -7, -10, 1, 4, 6, 9}, |
| {-3, -4, -7, -10, 2, 3, 6, 9}, |
| {-1, -2, -3, -10, 0, 1, 2, 9}, |
| {-4, -6, -8, -9, 3, 5, 7, 8}, |
| {-3, -5, -7, -9, 2, 4, 6, 8}, |
| } |
| alpha := [16]byte{ |
| 0xff, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff, |
| 0xff, 0xff, 0xff, 0xff, |
| } |
| |
| r := endian.Reader(bytes.NewReader(src), device.BigEndian) |
| for by := 0; by < block_height; by++ { |
| for bx := 0; bx < block_width; bx++ { |
| if hasAlpha { |
| v64 := r.Uint64() |
| // ┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┓ |
| // ┃ Base ┃Multiplier ┃Table Index┃ |
| // ┣━━┯━━┯━━┯━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━┫ |
| // ┃₆₃│₆₂│₆₁│₆₀│₅₉│₅₈│₅₇│₅₆┃₅₅│₅₄│₅₃│₅₂┃₅₁│₅₀│₄₉│₄₈┃ |
| // ┖──┴──┴──┴──┴──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┚ |
| base := int(v64 >> 56) |
| mul := int((v64 >> 52) & 15) |
| modTbl := alphaModTbl[(v64>>48)&15] |
| for i := uint8(0); i < 16; i++ { |
| mod := modTbl[(v64>>(i*3))&7] |
| alpha[15-i] = sint.Byte(base + mod*mul) |
| } |
| } |
| |
| v64 := r.Uint64() |
| flip := (v64 >> 32) & 1 |
| diff := (v64 >> 33) & 1 |
| |
| mode := uint(0) |
| for i := uint(0); i < 3; i++ { |
| if diff == 0 { |
| // ┏━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━┳━━┓ |
| // ┃ R₀ ┃ R₁ ┃ G₀ ┃ G₁ ┃ B₀ ┃ B₁ ┃ C₀ ┃ C₁ ┃df┃fp┃ |
| // ┣━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━╋━━╋━━┫ |
| // ┃₆₃│₆₂│₆₁│₆₀┃₅₉│₅₈│₅₇│₅₆┃₅₅│₅₄│₅₃│₅₂┃₅₁│₅₀│₄₉│₄₈┃₄₇│₄₆│₄₅│₄₄┃₄₃│₄₂│₄₁│₄₀┃₃₉│₃₈│₃₇┃₃₆│₃₅│₃₄┃₃₃┃₃₂┃ |
| // ┖──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┸──┴──┴──┸──┸──┚ |
| a := (v64 >> (60 - i*8)) & 15 |
| b := (v64 >> (56 - i*8)) & 15 |
| c[0][i] = int((a << 4) | a) |
| c[1][i] = int((b << 4) | b) |
| } else { |
| // ┏━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━┳━━┓ |
| // ┃ R₀ ┃Delta R₀┃ G₀ ┃Delta G₀┃ B₀ ┃Delta B₀┃ C₀ ┃ C₁ ┃df┃fp┃ |
| // ┣━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━╋━━╋━━┫ |
| // ┃₆₃│₆₂│₆₁│₆₀│₅₉┃₅₈│₅₇│₅₆┃₅₅│₅₄│₅₃│₅₂│₅₁┃₅₀│₄₉│₄₈┃₄₇│₄₆│₄₅│₄₄│₄₃┃₄₂│₄₁│₄₀┃₃₉│₃₈│₃₇┃₃₆│₃₅│₃₄┃₃₃┃₃₂┃ |
| // ┖──┴──┴──┴──┴──┸──┴──┴──┸──┴──┴──┴──┴──┸──┴──┴──┸──┴──┴──┴──┴──┸──┴──┴──┸──┴──┴──┸──┴──┴──┸──┸──┚ |
| a := (v64 >> (59 - i*8)) & 31 |
| d := (v64 >> (56 - i*8)) & 7 |
| b := int(a) + diffTbl[d] |
| if b < 0 || b > 31 { |
| mode = i + 1 |
| break |
| } |
| c[0][i] = int((a << 3) | (a >> 2)) |
| c[1][i] = int((b << 3) | (b >> 2)) |
| } |
| } |
| |
| switch mode { |
| case 0: // ETC1 |
| codes[0] = modTbl0[(v64>>37)&7] |
| codes[1] = modTbl0[(v64>>34)&7] |
| |
| blockTbl := flipTbl[flip] |
| |
| i := uint(0) |
| for x := bx * 4; x < (bx+1)*4; x++ { |
| for y := by * 4; y < (by+1)*4; y++ { |
| if x < width && y < height { |
| block := blockTbl[i] |
| base := c[block] |
| k := 4 * (y*width + x) |
| idx := ((v64 >> i) & 1) | ((v64 >> (15 + i)) & 2) |
| shift := codes[block][idx] |
| dst[k+2] = sint.Byte(base[2] + shift) |
| dst[k+1] = sint.Byte(base[1] + shift) |
| dst[k+0] = sint.Byte(base[0] + shift) |
| dst[k+3] = alpha[i] |
| } |
| i++ |
| } |
| } |
| case 1: // T-mode |
| // ┏━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┓ |
| // ┃ ┃ R₀ ┏━━┓ ┃ G₀ ┃ B₀ ┃ R₂ ┃ G₂ ┃ B₂ ┃ ┏━━┓ ┃ |
| // ┣━━┯━━┯━━╋━━┯━━╋━━╋━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━╋━━╋━━┫ |
| // ┃₆₃│₆₂│₆₁┃₆₀│₅₉┃₅₈┃₅₇│₅₆┃₅₅│₅₄│₅₃│₅₂┃₅₁│₅₀│₄₉│₄₈┃₄₇│₄₆│₄₅│₄₄┃₄₃│₄₂│₄₁│₄₀┃₃₉│₃₈│₃₇│₃₆┃₃₅│₃₄┃₃₃┃₃₂┃ |
| // ┖──┴──┴──┸──┴──┸──┸──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┸──┸──┚ |
| |
| // Load colors |
| c[0][R] = int(u64.Expand4to8(((v64 >> 57) & 12) | (v64>>56)&3)) |
| c[0][G] = int(u64.Expand4to8(v64 >> 52)) |
| c[0][B] = int(u64.Expand4to8(v64 >> 48)) |
| c[2][R] = int(u64.Expand4to8(v64 >> 44)) |
| c[2][G] = int(u64.Expand4to8(v64 >> 40)) |
| c[2][B] = int(u64.Expand4to8(v64 >> 36)) |
| |
| // Load intensity modifier |
| modIdx := ((v64 >> 33) & 6) | ((v64 >> 32) & 1) |
| mod := modTbl1[modIdx] |
| // Calculate C₁ and c₃ |
| for i := 0; i < 3; i++ { |
| c[1][i] = c[2][i] + mod |
| c[3][i] = c[2][i] - mod |
| } |
| // ┏━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┓ |
| // ┃ x₀ ┃ x₀ ┃ x₀ ┃ x₀ ┃ x₁ ┃ x₁ ┃ x₁ ┃ x₁ ┃ x₂ ┃ x₂ ┃ x₂ ┃ x₂ ┃ x₃ ┃ x₃ ┃ x₃ ┃ x₃ ┃ |
| // ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ |
| // ┣━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━┫ |
| // ┃₃₁│₃₀┃₂₉│₂₈┃₂₇│₂₆┃₂₅│₂₄┃₂₃│₂₂┃₂₁│₂₀┃₁₉│₁₈┃₁₇│₁₆┃₁₅│₁₄┃₁₃│₁₂┃₁₁│₁₀┃ ₉│ ₈┃ ₇│ ₆┃ ₅│ ₄┃ ₃│ ₂┃ ₁│ ₀┃ |
| // ┖──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┚ |
| // Use 2-bit indices to lookup texel colors |
| i := uint(0) |
| for x := bx * 4; x < (bx+1)*4; x++ { |
| for y := by * 4; y < (by+1)*4; y++ { |
| if x < width && y < height { |
| k := 4 * (y*width + x) |
| idx := ((v64 >> i) & 1) | ((v64 >> (15 + i)) & 2) |
| dst[k+0] = sint.Byte(c[idx][0]) |
| dst[k+1] = sint.Byte(c[idx][1]) |
| dst[k+2] = sint.Byte(c[idx][2]) |
| dst[k+3] = alpha[i] |
| } |
| i++ |
| } |
| } |
| case 2: // H-mode |
| // ┏━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━┓ |
| // ┃ ┃ R₀ ┃ G₀ ┏━━━━━━━━┓ ┃ ┏━━┓ B₀ ┃ R₂ ┃ G₂ ┃ B₂ ┃md┏━━┓ ┃ |
| // ┣━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━╋━━┯━━┯━━╋━━╋━━╋━━╋━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━╋━━╋━━╋━━┫ |
| // ┃₆₃┃₆₂│₆₁│₆₀│₅₉┃₅₈│₅₇│₅₆┃₅₅│₅₄│₅₃┃₅₂┃₅₁┃₅₀┃₄₉│₄₈│₄₇┃₄₆│₄₅│₄₄│₄₃┃₄₂│₄₁│₄₀│₃₉┃₃₈│₃₇│₃₆│₃₅┃₃₄┃₃₃┃₃₂┃ |
| // ┖──┸──┴──┴──┴──┸──┴──┴──┸──┴──┴──┸──┸──┸──┸──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┴──┴──┴──┸──┸──┸──┚ |
| |
| // Load colors |
| c[0][R] = int(u64.Expand4to8(v64 >> 59)) |
| c[0][G] = int(u64.Expand4to8(((v64 >> 55) & 14) | ((v64 >> 52) & 1))) |
| c[0][B] = int(u64.Expand4to8(((v64 >> 48) & 8) | ((v64 >> 47) & 7))) |
| c[2][R] = int(u64.Expand4to8(v64 >> 43)) |
| c[2][G] = int(u64.Expand4to8(v64 >> 39)) |
| c[2][B] = int(u64.Expand4to8(v64 >> 35)) |
| |
| // Load intensity modifier |
| modIdx := ((v64 >> 32) & 4) | ((v64 >> 31) & 2) |
| // LSB of modIdx is 1 if: |
| if (c[0][R]<<16)+(c[0][G]<<8)+c[0][B] >= (c[2][R]<<16)+(c[2][G]<<8)+c[2][B] { |
| modIdx++ |
| } |
| mod := modTbl1[modIdx] |
| // Calculate C₁ and c₃ |
| for i := 0; i < 3; i++ { |
| c[0][i], c[1][i] = c[0][i]+mod, c[0][i]-mod |
| c[2][i], c[3][i] = c[2][i]+mod, c[2][i]-mod |
| } |
| // ┏━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┳━━━━━┓ |
| // ┃ x₀ ┃ x₀ ┃ x₀ ┃ x₀ ┃ x₁ ┃ x₁ ┃ x₁ ┃ x₁ ┃ x₂ ┃ x₂ ┃ x₂ ┃ x₂ ┃ x₃ ┃ x₃ ┃ x₃ ┃ x₃ ┃ |
| // ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ y₀ ┃ y₁ ┃ y₂ ┃ y₃ ┃ |
| // ┣━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━╋━━┯━━┫ |
| // ┃₃₁│₃₀┃₂₉│₂₈┃₂₇│₂₆┃₂₅│₂₄┃₂₃│₂₂┃₂₁│₂₀┃₁₉│₁₈┃₁₇│₁₆┃₁₅│₁₄┃₁₃│₁₂┃₁₁│₁₀┃ ₉│ ₈┃ ₇│ ₆┃ ₅│ ₄┃ ₃│ ₂┃ ₁│ ₀┃ |
| // ┖──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┸──┴──┚ |
| // Use 2-bit indices to lookup texel colors |
| i := uint(0) |
| for x := bx * 4; x < (bx+1)*4; x++ { |
| for y := by * 4; y < (by+1)*4; y++ { |
| if x < width && y < height { |
| k := 4 * (y*width + x) |
| idx := ((v64 >> i) & 1) | ((v64 >> (15 + i)) & 2) |
| dst[k+0] = sint.Byte(c[idx][0]) |
| dst[k+1] = sint.Byte(c[idx][1]) |
| dst[k+2] = sint.Byte(c[idx][2]) |
| dst[k+3] = alpha[i] |
| } |
| i++ |
| } |
| } |
| case 3: // planar-mode |
| // ┏━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┓ |
| // ┃ ┃ R₀ ┃ ┏━━┓ G₀ ┃ ┏━━━━━━━━┓ B₀ ┏━━┓ ┃ R₁ ┏━━┓ ┃ |
| // ┣━━╋━━┯━━┯━━┯━━┯━━┯━━╋━━╋━━╋━━┯━━┯━━┯━━┯━━┯━━╋━━╋━━┯━━┯━━╋━━┯━━╋━━╋━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━╋━━╋━━┫ |
| // ┃₆₃┃₆₂│₆₁│₆₀│₅₉│₅₈│₅₇┃₅₆┃₅₅┃₅₄│₅₃│₅₂│₅₁│₅₀│₄₉┃₄₈┃₄₇│₄₆│₄₅┃₄₄│₄₃┃₄₂┃₄₁│₄₀│₃₉┃₃₈│₃₇│₃₆│₃₅│₃₄┃₃₃┃₃₂┃ |
| // ┖──┸──┴──┴──┴──┴──┴──┸──┸──┸──┴──┴──┴──┴──┴──┸──┸──┴──┴──┸──┴──┸──┸──┴──┴──┸──┴──┴──┴──┴──┸──┸──┚ |
| // |
| // ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓ |
| // ┃ G₁ ┃ B₁ ┃ R₂ ┃ G₂ ┃ B₂ ┃ |
| // ┣━━┯━━┯━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━┯━━┯━━╋━━┯━━┯━━┯━━┯━━┯━━┫ |
| // ┃₃₁│₃₀│₂₉│₂₈│₂₇│₂₆│₂₅┃₂₄│₂₃│₂₂│₂₁│₂₀│₁₉┃₁₈│₁₇│₁₆│₁₅│₁₄│₁₃┃₁₂│₁₁│₁₀│ ₉│ ₈│ ₇│ ₆┃ ₅│ ₄│ ₃│ ₂│ ₁│ ₀┃ |
| // ┖──┴──┴──┴──┴──┴──┴──┸──┴──┴──┴──┴──┴──┸──┴──┴──┴──┴──┴──┸──┴──┴──┴──┴──┴──┴──┸──┴──┴──┴──┴──┴──┚ |
| |
| // Load colors |
| c[0][R] = int(u64.Expand6to8(v64 >> 57)) |
| c[0][G] = int(u64.Expand7to8(((v64 >> 50) & 64) | ((v64 >> 49) & 63))) |
| c[0][B] = int(u64.Expand6to8(((v64 >> 43) & 32) | ((v64 >> 40) & 24) | ((v64 >> 39) & 7))) |
| |
| c[1][R] = int(u64.Expand6to8(((v64 >> 33) & 62) | ((v64 >> 32) & 1))) |
| c[1][G] = int(u64.Expand7to8(v64 >> 25)) |
| c[1][B] = int(u64.Expand6to8(v64 >> 19)) |
| |
| c[2][R] = int(u64.Expand6to8(v64 >> 13)) |
| c[2][G] = int(u64.Expand7to8(v64 >> 6)) |
| c[2][B] = int(u64.Expand6to8(v64)) |
| |
| i := 0 |
| for dx := 0; dx < 4; dx++ { |
| x := bx*4 + dx |
| for dy := 0; dy < 4; dy++ { |
| y := by*4 + dy |
| if x < width && y < height { |
| k := 4 * (y*width + x) |
| dst[k+0] = sint.Byte((dx*(c[1][R]-c[0][R]) + dy*(c[2][R]-c[0][R]) + 4*c[0][R] + 2) >> 2) |
| dst[k+1] = sint.Byte((dx*(c[1][G]-c[0][G]) + dy*(c[2][G]-c[0][G]) + 4*c[0][G] + 2) >> 2) |
| dst[k+2] = sint.Byte((dx*(c[1][B]-c[0][B]) + dy*(c[2][B]-c[0][B]) + 4*c[0][B] + 2) >> 2) |
| dst[k+3] = alpha[i] |
| } |
| i++ |
| } |
| } |
| } |
| } |
| } |
| |
| return dst, nil |
| } |
