| /* | |
| * Copyright 2016 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "SkPngFilters.h" | |
| // Functions in this file look at most 3 pixels (a,b,c) to predict the fourth (d). | |
| // They're positioned like this: | |
| // prev: c b | |
| // row: a d | |
| // The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be whichever | |
| // of a, b, or c is closest to p=a+b-c. (Up also exists, predicting d=b.) | |
| #if defined(__SSE2__) | |
| static __m128i load3(const void* p) { | |
| uint32_t packed; | |
| memcpy(&packed, p, 3); | |
| return _mm_cvtsi32_si128(packed); | |
| } | |
| static __m128i load4(const void* p) { | |
| return _mm_cvtsi32_si128(*(const int*)p); | |
| } | |
| static void store3(void* p, __m128i v) { | |
| uint32_t packed = _mm_cvtsi128_si32(v); | |
| memcpy(p, &packed, 3); | |
| } | |
| static void store4(void* p, __m128i v) { | |
| *(int*)p = _mm_cvtsi128_si32(v); | |
| } | |
| void sk_sub3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // The Sub filter predicts each pixel as the previous pixel, a. | |
| // There is no pixel to the left of the first pixel. It's encoded directly. | |
| // That works with our main loop if we just say that left pixel was zero. | |
| __m128i a, d = _mm_setzero_si128(); | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| a = d; d = load3(row); | |
| d = _mm_add_epi8(d, a); | |
| store3(row, d); | |
| row += 3; | |
| rb -= 3; | |
| } | |
| } | |
| void sk_sub4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // The Sub filter predicts each pixel as the previous pixel, a. | |
| // There is no pixel to the left of the first pixel. It's encoded directly. | |
| // That works with our main loop if we just say that left pixel was zero. | |
| __m128i a, d = _mm_setzero_si128(); | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| a = d; d = load4(row); | |
| d = _mm_add_epi8(d, a); | |
| store4(row, d); | |
| row += 4; | |
| rb -= 4; | |
| } | |
| } | |
| void sk_avg3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // The Avg filter predicts each pixel as the (truncated) average of a and b. | |
| // There's no pixel to the left of the first pixel. Luckily, it's | |
| // predicted to be half of the pixel above it. So again, this works | |
| // perfectly with our loop if we make sure a starts at zero. | |
| const __m128i zero = _mm_setzero_si128(); | |
| __m128i b; | |
| __m128i a, d = zero; | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| b = load3(prev); | |
| a = d; d = load3(row ); | |
| // PNG requires a truncating average here, so sadly we can't just use _mm_avg_epu8... | |
| __m128i avg = _mm_avg_epu8(a,b); | |
| // ...but we can fix it up by subtracting off 1 if it rounded up. | |
| avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b), _mm_set1_epi8(1))); | |
| d = _mm_add_epi8(d, avg); | |
| store3(row, d); | |
| prev += 3; | |
| row += 3; | |
| rb -= 3; | |
| } | |
| } | |
| void sk_avg4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // The Avg filter predicts each pixel as the (truncated) average of a and b. | |
| // There's no pixel to the left of the first pixel. Luckily, it's | |
| // predicted to be half of the pixel above it. So again, this works | |
| // perfectly with our loop if we make sure a starts at zero. | |
| const __m128i zero = _mm_setzero_si128(); | |
| __m128i b; | |
| __m128i a, d = zero; | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| b = load4(prev); | |
| a = d; d = load4(row ); | |
| // PNG requires a truncating average here, so sadly we can't just use _mm_avg_epu8... | |
| __m128i avg = _mm_avg_epu8(a,b); | |
| // ...but we can fix it up by subtracting off 1 if it rounded up. | |
| avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b), _mm_set1_epi8(1))); | |
| d = _mm_add_epi8(d, avg); | |
| store4(row, d); | |
| prev += 4; | |
| row += 4; | |
| rb -= 4; | |
| } | |
| } | |
| // Returns |x| for 16-bit lanes. | |
| static __m128i abs_i16(__m128i x) { | |
| #if defined(__SSSE3__) | |
| return _mm_abs_epi16(x); | |
| #else | |
| // Read this all as, return x<0 ? -x : x. | |
| // To negate two's complement, you flip all the bits then add 1. | |
| __m128i is_negative = _mm_cmplt_epi16(x, _mm_setzero_si128()); | |
| x = _mm_xor_si128(x, is_negative); // Flip negative lanes. | |
| x = _mm_add_epi16(x, _mm_srli_epi16(is_negative, 15)); // +1 to negative lanes, else +0. | |
| return x; | |
| #endif | |
| } | |
| // Bytewise c ? t : e. | |
| static __m128i if_then_else(__m128i c, __m128i t, __m128i e) { | |
| #if defined(__SSE4_1__) | |
| return _mm_blendv_epi8(e,t,c); | |
| #else | |
| return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e)); | |
| #endif | |
| } | |
| void sk_paeth3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // Paeth tries to predict pixel d using the pixel to the left of it, a, | |
| // and two pixels from the previous row, b and c: | |
| // prev: c b | |
| // row: a d | |
| // The Paeth function predicts d to be whichever of a, b, or c is nearest to p=a+b-c. | |
| // The first pixel has no left context, and so uses an Up filter, p = b. | |
| // This works naturally with our main loop's p = a+b-c if we force a and c to zero. | |
| // Here we zero b and d, which become c and a respectively at the start of the loop. | |
| const __m128i zero = _mm_setzero_si128(); | |
| __m128i c, b = zero, | |
| a, d = zero; | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| // It's easiest to do this math (particularly, deal with pc) with 16-bit intermediates. | |
| c = b; b = _mm_unpacklo_epi8(load3(prev), zero); | |
| a = d; d = _mm_unpacklo_epi8(load3(row ), zero); | |
| __m128i pa = _mm_sub_epi16(b,c), // (p-a) == (a+b-c - a) == (b-c) | |
| pb = _mm_sub_epi16(a,c), // (p-b) == (a+b-c - b) == (a-c) | |
| pc = _mm_add_epi16(pa,pb); // (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) | |
| pa = abs_i16(pa); // |p-a| | |
| pb = abs_i16(pb); // |p-b| | |
| pc = abs_i16(pc); // |p-c| | |
| __m128i smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb)); | |
| // Paeth breaks ties favoring a over b over c. | |
| __m128i nearest = if_then_else(_mm_cmpeq_epi16(smallest, pa), a, | |
| if_then_else(_mm_cmpeq_epi16(smallest, pb), b, | |
| c)); | |
| d = _mm_add_epi8(d, nearest); // Note `_epi8`: we need addition to wrap modulo 255. | |
| store3(row, _mm_packus_epi16(d,d)); | |
| prev += 3; | |
| row += 3; | |
| rb -= 3; | |
| } | |
| } | |
| void sk_paeth4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) { | |
| // Paeth tries to predict pixel d using the pixel to the left of it, a, | |
| // and two pixels from the previous row, b and c: | |
| // prev: c b | |
| // row: a d | |
| // The Paeth function predicts d to be whichever of a, b, or c is nearest to p=a+b-c. | |
| // The first pixel has no left context, and so uses an Up filter, p = b. | |
| // This works naturally with our main loop's p = a+b-c if we force a and c to zero. | |
| // Here we zero b and d, which become c and a respectively at the start of the loop. | |
| const __m128i zero = _mm_setzero_si128(); | |
| __m128i c, b = zero, | |
| a, d = zero; | |
| int rb = row_info->rowbytes; | |
| while (rb > 0) { | |
| // It's easiest to do this math (particularly, deal with pc) with 16-bit intermediates. | |
| c = b; b = _mm_unpacklo_epi8(load4(prev), zero); | |
| a = d; d = _mm_unpacklo_epi8(load4(row ), zero); | |
| __m128i pa = _mm_sub_epi16(b,c), // (p-a) == (a+b-c - a) == (b-c) | |
| pb = _mm_sub_epi16(a,c), // (p-b) == (a+b-c - b) == (a-c) | |
| pc = _mm_add_epi16(pa,pb); // (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) | |
| pa = abs_i16(pa); // |p-a| | |
| pb = abs_i16(pb); // |p-b| | |
| pc = abs_i16(pc); // |p-c| | |
| __m128i smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb)); | |
| // Paeth breaks ties favoring a over b over c. | |
| __m128i nearest = if_then_else(_mm_cmpeq_epi16(smallest, pa), a, | |
| if_then_else(_mm_cmpeq_epi16(smallest, pb), b, | |
| c)); | |
| d = _mm_add_epi8(d, nearest); // Note `_epi8`: we need addition to wrap modulo 255. | |
| store4(row, _mm_packus_epi16(d,d)); | |
| prev += 4; | |
| row += 4; | |
| rb -= 4; | |
| } | |
| } | |
| #endif |