mirror of
https://github.com/webmproject/libwebp.git
synced 2024-11-20 12:28:26 +01:00
0d5fad46cf
this internalizes the init checks and provides stronger synchronization
with pthreads when available while still allowing VP8GetCPUInfo to be
modified (mostly for testing purposes). windows is left as is since a
critical section or mutex would cause a leak.
Change-Id: Ieb997e014f2805c0ae39c16f13337663521356f4
(cherry picked from commit d77bf512bd)
473 lines
18 KiB
C
473 lines
18 KiB
C
// Copyright 2013 Google Inc. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the COPYING file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// Utilities for processing transparent channel.
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <assert.h>
|
|
#include "src/dsp/dsp.h"
|
|
|
|
// Tables can be faster on some platform but incur some extra binary size (~2k).
|
|
#if !defined(USE_TABLES_FOR_ALPHA_MULT)
|
|
#define USE_TABLES_FOR_ALPHA_MULT 0 // ALTERNATE_CODE
|
|
#endif
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#define MFIX 24 // 24bit fixed-point arithmetic
|
|
#define HALF ((1u << MFIX) >> 1)
|
|
#define KINV_255 ((1u << MFIX) / 255u)
|
|
|
|
static uint32_t Mult(uint8_t x, uint32_t mult) {
|
|
const uint32_t v = (x * mult + HALF) >> MFIX;
|
|
assert(v <= 255); // <- 24bit precision is enough to ensure that.
|
|
return v;
|
|
}
|
|
|
|
#if (USE_TABLES_FOR_ALPHA_MULT == 1)
|
|
|
|
static const uint32_t kMultTables[2][256] = {
|
|
{ // (255u << MFIX) / alpha
|
|
0x00000000, 0xff000000, 0x7f800000, 0x55000000, 0x3fc00000, 0x33000000,
|
|
0x2a800000, 0x246db6db, 0x1fe00000, 0x1c555555, 0x19800000, 0x172e8ba2,
|
|
0x15400000, 0x139d89d8, 0x1236db6d, 0x11000000, 0x0ff00000, 0x0f000000,
|
|
0x0e2aaaaa, 0x0d6bca1a, 0x0cc00000, 0x0c249249, 0x0b9745d1, 0x0b1642c8,
|
|
0x0aa00000, 0x0a333333, 0x09cec4ec, 0x0971c71c, 0x091b6db6, 0x08cb08d3,
|
|
0x08800000, 0x0839ce73, 0x07f80000, 0x07ba2e8b, 0x07800000, 0x07492492,
|
|
0x07155555, 0x06e45306, 0x06b5e50d, 0x0689d89d, 0x06600000, 0x063831f3,
|
|
0x06124924, 0x05ee23b8, 0x05cba2e8, 0x05aaaaaa, 0x058b2164, 0x056cefa8,
|
|
0x05500000, 0x05343eb1, 0x05199999, 0x05000000, 0x04e76276, 0x04cfb2b7,
|
|
0x04b8e38e, 0x04a2e8ba, 0x048db6db, 0x0479435e, 0x04658469, 0x045270d0,
|
|
0x04400000, 0x042e29f7, 0x041ce739, 0x040c30c3, 0x03fc0000, 0x03ec4ec4,
|
|
0x03dd1745, 0x03ce540f, 0x03c00000, 0x03b21642, 0x03a49249, 0x03976fc6,
|
|
0x038aaaaa, 0x037e3f1f, 0x03722983, 0x03666666, 0x035af286, 0x034fcace,
|
|
0x0344ec4e, 0x033a5440, 0x03300000, 0x0325ed09, 0x031c18f9, 0x0312818a,
|
|
0x03092492, 0x03000000, 0x02f711dc, 0x02ee5846, 0x02e5d174, 0x02dd7baf,
|
|
0x02d55555, 0x02cd5cd5, 0x02c590b2, 0x02bdef7b, 0x02b677d4, 0x02af286b,
|
|
0x02a80000, 0x02a0fd5c, 0x029a1f58, 0x029364d9, 0x028ccccc, 0x0286562d,
|
|
0x02800000, 0x0279c952, 0x0273b13b, 0x026db6db, 0x0267d95b, 0x026217ec,
|
|
0x025c71c7, 0x0256e62a, 0x0251745d, 0x024c1bac, 0x0246db6d, 0x0241b2f9,
|
|
0x023ca1af, 0x0237a6f4, 0x0232c234, 0x022df2df, 0x02293868, 0x02249249,
|
|
0x02200000, 0x021b810e, 0x021714fb, 0x0212bb51, 0x020e739c, 0x020a3d70,
|
|
0x02061861, 0x02020408, 0x01fe0000, 0x01fa0be8, 0x01f62762, 0x01f25213,
|
|
0x01ee8ba2, 0x01ead3ba, 0x01e72a07, 0x01e38e38, 0x01e00000, 0x01dc7f10,
|
|
0x01d90b21, 0x01d5a3e9, 0x01d24924, 0x01cefa8d, 0x01cbb7e3, 0x01c880e5,
|
|
0x01c55555, 0x01c234f7, 0x01bf1f8f, 0x01bc14e5, 0x01b914c1, 0x01b61eed,
|
|
0x01b33333, 0x01b05160, 0x01ad7943, 0x01aaaaaa, 0x01a7e567, 0x01a5294a,
|
|
0x01a27627, 0x019fcbd2, 0x019d2a20, 0x019a90e7, 0x01980000, 0x01957741,
|
|
0x0192f684, 0x01907da4, 0x018e0c7c, 0x018ba2e8, 0x018940c5, 0x0186e5f0,
|
|
0x01849249, 0x018245ae, 0x01800000, 0x017dc11f, 0x017b88ee, 0x0179574e,
|
|
0x01772c23, 0x01750750, 0x0172e8ba, 0x0170d045, 0x016ebdd7, 0x016cb157,
|
|
0x016aaaaa, 0x0168a9b9, 0x0166ae6a, 0x0164b8a7, 0x0162c859, 0x0160dd67,
|
|
0x015ef7bd, 0x015d1745, 0x015b3bea, 0x01596596, 0x01579435, 0x0155c7b4,
|
|
0x01540000, 0x01523d03, 0x01507eae, 0x014ec4ec, 0x014d0fac, 0x014b5edc,
|
|
0x0149b26c, 0x01480a4a, 0x01466666, 0x0144c6af, 0x01432b16, 0x0141938b,
|
|
0x01400000, 0x013e7063, 0x013ce4a9, 0x013b5cc0, 0x0139d89d, 0x01385830,
|
|
0x0136db6d, 0x01356246, 0x0133ecad, 0x01327a97, 0x01310bf6, 0x012fa0be,
|
|
0x012e38e3, 0x012cd459, 0x012b7315, 0x012a150a, 0x0128ba2e, 0x01276276,
|
|
0x01260dd6, 0x0124bc44, 0x01236db6, 0x01222222, 0x0120d97c, 0x011f93bc,
|
|
0x011e50d7, 0x011d10c4, 0x011bd37a, 0x011a98ef, 0x0119611a, 0x01182bf2,
|
|
0x0116f96f, 0x0115c988, 0x01149c34, 0x0113716a, 0x01124924, 0x01112358,
|
|
0x01100000, 0x010edf12, 0x010dc087, 0x010ca458, 0x010b8a7d, 0x010a72f0,
|
|
0x01095da8, 0x01084a9f, 0x010739ce, 0x01062b2e, 0x01051eb8, 0x01041465,
|
|
0x01030c30, 0x01020612, 0x01010204, 0x01000000 },
|
|
{ // alpha * KINV_255
|
|
0x00000000, 0x00010101, 0x00020202, 0x00030303, 0x00040404, 0x00050505,
|
|
0x00060606, 0x00070707, 0x00080808, 0x00090909, 0x000a0a0a, 0x000b0b0b,
|
|
0x000c0c0c, 0x000d0d0d, 0x000e0e0e, 0x000f0f0f, 0x00101010, 0x00111111,
|
|
0x00121212, 0x00131313, 0x00141414, 0x00151515, 0x00161616, 0x00171717,
|
|
0x00181818, 0x00191919, 0x001a1a1a, 0x001b1b1b, 0x001c1c1c, 0x001d1d1d,
|
|
0x001e1e1e, 0x001f1f1f, 0x00202020, 0x00212121, 0x00222222, 0x00232323,
|
|
0x00242424, 0x00252525, 0x00262626, 0x00272727, 0x00282828, 0x00292929,
|
|
0x002a2a2a, 0x002b2b2b, 0x002c2c2c, 0x002d2d2d, 0x002e2e2e, 0x002f2f2f,
|
|
0x00303030, 0x00313131, 0x00323232, 0x00333333, 0x00343434, 0x00353535,
|
|
0x00363636, 0x00373737, 0x00383838, 0x00393939, 0x003a3a3a, 0x003b3b3b,
|
|
0x003c3c3c, 0x003d3d3d, 0x003e3e3e, 0x003f3f3f, 0x00404040, 0x00414141,
|
|
0x00424242, 0x00434343, 0x00444444, 0x00454545, 0x00464646, 0x00474747,
|
|
0x00484848, 0x00494949, 0x004a4a4a, 0x004b4b4b, 0x004c4c4c, 0x004d4d4d,
|
|
0x004e4e4e, 0x004f4f4f, 0x00505050, 0x00515151, 0x00525252, 0x00535353,
|
|
0x00545454, 0x00555555, 0x00565656, 0x00575757, 0x00585858, 0x00595959,
|
|
0x005a5a5a, 0x005b5b5b, 0x005c5c5c, 0x005d5d5d, 0x005e5e5e, 0x005f5f5f,
|
|
0x00606060, 0x00616161, 0x00626262, 0x00636363, 0x00646464, 0x00656565,
|
|
0x00666666, 0x00676767, 0x00686868, 0x00696969, 0x006a6a6a, 0x006b6b6b,
|
|
0x006c6c6c, 0x006d6d6d, 0x006e6e6e, 0x006f6f6f, 0x00707070, 0x00717171,
|
|
0x00727272, 0x00737373, 0x00747474, 0x00757575, 0x00767676, 0x00777777,
|
|
0x00787878, 0x00797979, 0x007a7a7a, 0x007b7b7b, 0x007c7c7c, 0x007d7d7d,
|
|
0x007e7e7e, 0x007f7f7f, 0x00808080, 0x00818181, 0x00828282, 0x00838383,
|
|
0x00848484, 0x00858585, 0x00868686, 0x00878787, 0x00888888, 0x00898989,
|
|
0x008a8a8a, 0x008b8b8b, 0x008c8c8c, 0x008d8d8d, 0x008e8e8e, 0x008f8f8f,
|
|
0x00909090, 0x00919191, 0x00929292, 0x00939393, 0x00949494, 0x00959595,
|
|
0x00969696, 0x00979797, 0x00989898, 0x00999999, 0x009a9a9a, 0x009b9b9b,
|
|
0x009c9c9c, 0x009d9d9d, 0x009e9e9e, 0x009f9f9f, 0x00a0a0a0, 0x00a1a1a1,
|
|
0x00a2a2a2, 0x00a3a3a3, 0x00a4a4a4, 0x00a5a5a5, 0x00a6a6a6, 0x00a7a7a7,
|
|
0x00a8a8a8, 0x00a9a9a9, 0x00aaaaaa, 0x00ababab, 0x00acacac, 0x00adadad,
|
|
0x00aeaeae, 0x00afafaf, 0x00b0b0b0, 0x00b1b1b1, 0x00b2b2b2, 0x00b3b3b3,
|
|
0x00b4b4b4, 0x00b5b5b5, 0x00b6b6b6, 0x00b7b7b7, 0x00b8b8b8, 0x00b9b9b9,
|
|
0x00bababa, 0x00bbbbbb, 0x00bcbcbc, 0x00bdbdbd, 0x00bebebe, 0x00bfbfbf,
|
|
0x00c0c0c0, 0x00c1c1c1, 0x00c2c2c2, 0x00c3c3c3, 0x00c4c4c4, 0x00c5c5c5,
|
|
0x00c6c6c6, 0x00c7c7c7, 0x00c8c8c8, 0x00c9c9c9, 0x00cacaca, 0x00cbcbcb,
|
|
0x00cccccc, 0x00cdcdcd, 0x00cecece, 0x00cfcfcf, 0x00d0d0d0, 0x00d1d1d1,
|
|
0x00d2d2d2, 0x00d3d3d3, 0x00d4d4d4, 0x00d5d5d5, 0x00d6d6d6, 0x00d7d7d7,
|
|
0x00d8d8d8, 0x00d9d9d9, 0x00dadada, 0x00dbdbdb, 0x00dcdcdc, 0x00dddddd,
|
|
0x00dedede, 0x00dfdfdf, 0x00e0e0e0, 0x00e1e1e1, 0x00e2e2e2, 0x00e3e3e3,
|
|
0x00e4e4e4, 0x00e5e5e5, 0x00e6e6e6, 0x00e7e7e7, 0x00e8e8e8, 0x00e9e9e9,
|
|
0x00eaeaea, 0x00ebebeb, 0x00ececec, 0x00ededed, 0x00eeeeee, 0x00efefef,
|
|
0x00f0f0f0, 0x00f1f1f1, 0x00f2f2f2, 0x00f3f3f3, 0x00f4f4f4, 0x00f5f5f5,
|
|
0x00f6f6f6, 0x00f7f7f7, 0x00f8f8f8, 0x00f9f9f9, 0x00fafafa, 0x00fbfbfb,
|
|
0x00fcfcfc, 0x00fdfdfd, 0x00fefefe, 0x00ffffff }
|
|
};
|
|
|
|
static WEBP_INLINE uint32_t GetScale(uint32_t a, int inverse) {
|
|
return kMultTables[!inverse][a];
|
|
}
|
|
|
|
#else
|
|
|
|
static WEBP_INLINE uint32_t GetScale(uint32_t a, int inverse) {
|
|
return inverse ? (255u << MFIX) / a : a * KINV_255;
|
|
}
|
|
|
|
#endif // USE_TABLES_FOR_ALPHA_MULT
|
|
|
|
void WebPMultARGBRow_C(uint32_t* const ptr, int width, int inverse) {
|
|
int x;
|
|
for (x = 0; x < width; ++x) {
|
|
const uint32_t argb = ptr[x];
|
|
if (argb < 0xff000000u) { // alpha < 255
|
|
if (argb <= 0x00ffffffu) { // alpha == 0
|
|
ptr[x] = 0;
|
|
} else {
|
|
const uint32_t alpha = (argb >> 24) & 0xff;
|
|
const uint32_t scale = GetScale(alpha, inverse);
|
|
uint32_t out = argb & 0xff000000u;
|
|
out |= Mult(argb >> 0, scale) << 0;
|
|
out |= Mult(argb >> 8, scale) << 8;
|
|
out |= Mult(argb >> 16, scale) << 16;
|
|
ptr[x] = out;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void WebPMultRow_C(uint8_t* const ptr, const uint8_t* const alpha,
|
|
int width, int inverse) {
|
|
int x;
|
|
for (x = 0; x < width; ++x) {
|
|
const uint32_t a = alpha[x];
|
|
if (a != 255) {
|
|
if (a == 0) {
|
|
ptr[x] = 0;
|
|
} else {
|
|
const uint32_t scale = GetScale(a, inverse);
|
|
ptr[x] = Mult(ptr[x], scale);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef KINV_255
|
|
#undef HALF
|
|
#undef MFIX
|
|
|
|
void (*WebPMultARGBRow)(uint32_t* const ptr, int width, int inverse);
|
|
void (*WebPMultRow)(uint8_t* const ptr, const uint8_t* const alpha,
|
|
int width, int inverse);
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Generic per-plane calls
|
|
|
|
void WebPMultARGBRows(uint8_t* ptr, int stride, int width, int num_rows,
|
|
int inverse) {
|
|
int n;
|
|
for (n = 0; n < num_rows; ++n) {
|
|
WebPMultARGBRow((uint32_t*)ptr, width, inverse);
|
|
ptr += stride;
|
|
}
|
|
}
|
|
|
|
void WebPMultRows(uint8_t* ptr, int stride,
|
|
const uint8_t* alpha, int alpha_stride,
|
|
int width, int num_rows, int inverse) {
|
|
int n;
|
|
for (n = 0; n < num_rows; ++n) {
|
|
WebPMultRow(ptr, alpha, width, inverse);
|
|
ptr += stride;
|
|
alpha += alpha_stride;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Premultiplied modes
|
|
|
|
// non dithered-modes
|
|
|
|
// (x * a * 32897) >> 23 is bit-wise equivalent to (int)(x * a / 255.)
|
|
// for all 8bit x or a. For bit-wise equivalence to (int)(x * a / 255. + .5),
|
|
// one can use instead: (x * a * 65793 + (1 << 23)) >> 24
|
|
#if 1 // (int)(x * a / 255.)
|
|
#define MULTIPLIER(a) ((a) * 32897U)
|
|
#define PREMULTIPLY(x, m) (((x) * (m)) >> 23)
|
|
#else // (int)(x * a / 255. + .5)
|
|
#define MULTIPLIER(a) ((a) * 65793U)
|
|
#define PREMULTIPLY(x, m) (((x) * (m) + (1U << 23)) >> 24)
|
|
#endif
|
|
|
|
#if !WEBP_NEON_OMIT_C_CODE
|
|
static void ApplyAlphaMultiply_C(uint8_t* rgba, int alpha_first,
|
|
int w, int h, int stride) {
|
|
while (h-- > 0) {
|
|
uint8_t* const rgb = rgba + (alpha_first ? 1 : 0);
|
|
const uint8_t* const alpha = rgba + (alpha_first ? 0 : 3);
|
|
int i;
|
|
for (i = 0; i < w; ++i) {
|
|
const uint32_t a = alpha[4 * i];
|
|
if (a != 0xff) {
|
|
const uint32_t mult = MULTIPLIER(a);
|
|
rgb[4 * i + 0] = PREMULTIPLY(rgb[4 * i + 0], mult);
|
|
rgb[4 * i + 1] = PREMULTIPLY(rgb[4 * i + 1], mult);
|
|
rgb[4 * i + 2] = PREMULTIPLY(rgb[4 * i + 2], mult);
|
|
}
|
|
}
|
|
rgba += stride;
|
|
}
|
|
}
|
|
#endif // !WEBP_NEON_OMIT_C_CODE
|
|
#undef MULTIPLIER
|
|
#undef PREMULTIPLY
|
|
|
|
// rgbA4444
|
|
|
|
#define MULTIPLIER(a) ((a) * 0x1111) // 0x1111 ~= (1 << 16) / 15
|
|
|
|
static WEBP_INLINE uint8_t dither_hi(uint8_t x) {
|
|
return (x & 0xf0) | (x >> 4);
|
|
}
|
|
|
|
static WEBP_INLINE uint8_t dither_lo(uint8_t x) {
|
|
return (x & 0x0f) | (x << 4);
|
|
}
|
|
|
|
static WEBP_INLINE uint8_t multiply(uint8_t x, uint32_t m) {
|
|
return (x * m) >> 16;
|
|
}
|
|
|
|
static WEBP_INLINE void ApplyAlphaMultiply4444_C(uint8_t* rgba4444,
|
|
int w, int h, int stride,
|
|
int rg_byte_pos /* 0 or 1 */) {
|
|
while (h-- > 0) {
|
|
int i;
|
|
for (i = 0; i < w; ++i) {
|
|
const uint32_t rg = rgba4444[2 * i + rg_byte_pos];
|
|
const uint32_t ba = rgba4444[2 * i + (rg_byte_pos ^ 1)];
|
|
const uint8_t a = ba & 0x0f;
|
|
const uint32_t mult = MULTIPLIER(a);
|
|
const uint8_t r = multiply(dither_hi(rg), mult);
|
|
const uint8_t g = multiply(dither_lo(rg), mult);
|
|
const uint8_t b = multiply(dither_hi(ba), mult);
|
|
rgba4444[2 * i + rg_byte_pos] = (r & 0xf0) | ((g >> 4) & 0x0f);
|
|
rgba4444[2 * i + (rg_byte_pos ^ 1)] = (b & 0xf0) | a;
|
|
}
|
|
rgba4444 += stride;
|
|
}
|
|
}
|
|
#undef MULTIPLIER
|
|
|
|
static void ApplyAlphaMultiply_16b_C(uint8_t* rgba4444,
|
|
int w, int h, int stride) {
|
|
#if (WEBP_SWAP_16BIT_CSP == 1)
|
|
ApplyAlphaMultiply4444_C(rgba4444, w, h, stride, 1);
|
|
#else
|
|
ApplyAlphaMultiply4444_C(rgba4444, w, h, stride, 0);
|
|
#endif
|
|
}
|
|
|
|
#if !WEBP_NEON_OMIT_C_CODE
|
|
static int DispatchAlpha_C(const uint8_t* alpha, int alpha_stride,
|
|
int width, int height,
|
|
uint8_t* dst, int dst_stride) {
|
|
uint32_t alpha_mask = 0xff;
|
|
int i, j;
|
|
|
|
for (j = 0; j < height; ++j) {
|
|
for (i = 0; i < width; ++i) {
|
|
const uint32_t alpha_value = alpha[i];
|
|
dst[4 * i] = alpha_value;
|
|
alpha_mask &= alpha_value;
|
|
}
|
|
alpha += alpha_stride;
|
|
dst += dst_stride;
|
|
}
|
|
|
|
return (alpha_mask != 0xff);
|
|
}
|
|
|
|
static void DispatchAlphaToGreen_C(const uint8_t* alpha, int alpha_stride,
|
|
int width, int height,
|
|
uint32_t* dst, int dst_stride) {
|
|
int i, j;
|
|
for (j = 0; j < height; ++j) {
|
|
for (i = 0; i < width; ++i) {
|
|
dst[i] = alpha[i] << 8; // leave A/R/B channels zero'd.
|
|
}
|
|
alpha += alpha_stride;
|
|
dst += dst_stride;
|
|
}
|
|
}
|
|
|
|
static int ExtractAlpha_C(const uint8_t* argb, int argb_stride,
|
|
int width, int height,
|
|
uint8_t* alpha, int alpha_stride) {
|
|
uint8_t alpha_mask = 0xff;
|
|
int i, j;
|
|
|
|
for (j = 0; j < height; ++j) {
|
|
for (i = 0; i < width; ++i) {
|
|
const uint8_t alpha_value = argb[4 * i];
|
|
alpha[i] = alpha_value;
|
|
alpha_mask &= alpha_value;
|
|
}
|
|
argb += argb_stride;
|
|
alpha += alpha_stride;
|
|
}
|
|
return (alpha_mask == 0xff);
|
|
}
|
|
|
|
static void ExtractGreen_C(const uint32_t* argb, uint8_t* alpha, int size) {
|
|
int i;
|
|
for (i = 0; i < size; ++i) alpha[i] = argb[i] >> 8;
|
|
}
|
|
#endif // !WEBP_NEON_OMIT_C_CODE
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
static int HasAlpha8b_C(const uint8_t* src, int length) {
|
|
while (length-- > 0) if (*src++ != 0xff) return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int HasAlpha32b_C(const uint8_t* src, int length) {
|
|
int x;
|
|
for (x = 0; length-- > 0; x += 4) if (src[x] != 0xff) return 1;
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Simple channel manipulations.
|
|
|
|
static WEBP_INLINE uint32_t MakeARGB32(int a, int r, int g, int b) {
|
|
return (((uint32_t)a << 24) | (r << 16) | (g << 8) | b);
|
|
}
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
static void PackARGB_C(const uint8_t* a, const uint8_t* r, const uint8_t* g,
|
|
const uint8_t* b, int len, uint32_t* out) {
|
|
int i;
|
|
for (i = 0; i < len; ++i) {
|
|
out[i] = MakeARGB32(a[4 * i], r[4 * i], g[4 * i], b[4 * i]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void PackRGB_C(const uint8_t* r, const uint8_t* g, const uint8_t* b,
|
|
int len, int step, uint32_t* out) {
|
|
int i, offset = 0;
|
|
for (i = 0; i < len; ++i) {
|
|
out[i] = MakeARGB32(0xff, r[offset], g[offset], b[offset]);
|
|
offset += step;
|
|
}
|
|
}
|
|
|
|
void (*WebPApplyAlphaMultiply)(uint8_t*, int, int, int, int);
|
|
void (*WebPApplyAlphaMultiply4444)(uint8_t*, int, int, int);
|
|
int (*WebPDispatchAlpha)(const uint8_t*, int, int, int, uint8_t*, int);
|
|
void (*WebPDispatchAlphaToGreen)(const uint8_t*, int, int, int, uint32_t*, int);
|
|
int (*WebPExtractAlpha)(const uint8_t*, int, int, int, uint8_t*, int);
|
|
void (*WebPExtractGreen)(const uint32_t* argb, uint8_t* alpha, int size);
|
|
#ifdef WORDS_BIGENDIAN
|
|
void (*WebPPackARGB)(const uint8_t* a, const uint8_t* r, const uint8_t* g,
|
|
const uint8_t* b, int, uint32_t*);
|
|
#endif
|
|
void (*WebPPackRGB)(const uint8_t* r, const uint8_t* g, const uint8_t* b,
|
|
int len, int step, uint32_t* out);
|
|
|
|
int (*WebPHasAlpha8b)(const uint8_t* src, int length);
|
|
int (*WebPHasAlpha32b)(const uint8_t* src, int length);
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Init function
|
|
|
|
extern void WebPInitAlphaProcessingMIPSdspR2(void);
|
|
extern void WebPInitAlphaProcessingSSE2(void);
|
|
extern void WebPInitAlphaProcessingSSE41(void);
|
|
extern void WebPInitAlphaProcessingNEON(void);
|
|
|
|
WEBP_DSP_INIT_FUNC(WebPInitAlphaProcessing) {
|
|
WebPMultARGBRow = WebPMultARGBRow_C;
|
|
WebPMultRow = WebPMultRow_C;
|
|
WebPApplyAlphaMultiply4444 = ApplyAlphaMultiply_16b_C;
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
WebPPackARGB = PackARGB_C;
|
|
#endif
|
|
WebPPackRGB = PackRGB_C;
|
|
#if !WEBP_NEON_OMIT_C_CODE
|
|
WebPApplyAlphaMultiply = ApplyAlphaMultiply_C;
|
|
WebPDispatchAlpha = DispatchAlpha_C;
|
|
WebPDispatchAlphaToGreen = DispatchAlphaToGreen_C;
|
|
WebPExtractAlpha = ExtractAlpha_C;
|
|
WebPExtractGreen = ExtractGreen_C;
|
|
#endif
|
|
|
|
WebPHasAlpha8b = HasAlpha8b_C;
|
|
WebPHasAlpha32b = HasAlpha32b_C;
|
|
|
|
// If defined, use CPUInfo() to overwrite some pointers with faster versions.
|
|
if (VP8GetCPUInfo != NULL) {
|
|
#if defined(WEBP_USE_SSE2)
|
|
if (VP8GetCPUInfo(kSSE2)) {
|
|
WebPInitAlphaProcessingSSE2();
|
|
#if defined(WEBP_USE_SSE41)
|
|
if (VP8GetCPUInfo(kSSE4_1)) {
|
|
WebPInitAlphaProcessingSSE41();
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
#if defined(WEBP_USE_MIPS_DSP_R2)
|
|
if (VP8GetCPUInfo(kMIPSdspR2)) {
|
|
WebPInitAlphaProcessingMIPSdspR2();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if defined(WEBP_USE_NEON)
|
|
if (WEBP_NEON_OMIT_C_CODE ||
|
|
(VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
|
|
WebPInitAlphaProcessingNEON();
|
|
}
|
|
#endif
|
|
|
|
assert(WebPMultARGBRow != NULL);
|
|
assert(WebPMultRow != NULL);
|
|
assert(WebPApplyAlphaMultiply != NULL);
|
|
assert(WebPApplyAlphaMultiply4444 != NULL);
|
|
assert(WebPDispatchAlpha != NULL);
|
|
assert(WebPDispatchAlphaToGreen != NULL);
|
|
assert(WebPExtractAlpha != NULL);
|
|
assert(WebPExtractGreen != NULL);
|
|
#ifdef WORDS_BIGENDIAN
|
|
assert(WebPPackARGB != NULL);
|
|
#endif
|
|
assert(WebPPackRGB != NULL);
|
|
assert(WebPHasAlpha8b != NULL);
|
|
assert(WebPHasAlpha32b != NULL);
|
|
}
|