vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b
This commit is contained in:
Gitea Mirror Bot
+525
@@ -0,0 +1,525 @@
|
||||
/* filter_mmi_intrinsics.c - MMI optimized filter functions
|
||||
*
|
||||
* Copyright (c) 2024 Cosmin Truta
|
||||
* Written by zhanglixia and guxiwei, 2023
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*/
|
||||
|
||||
#include "../pngpriv.h"
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
|
||||
#if PNG_MIPS_MMI_IMPLEMENTATION == 2 /* Inline Assembly */
|
||||
|
||||
/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (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.
|
||||
*/
|
||||
|
||||
void png_read_filter_row_up_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
int istop = row_info->rowbytes;
|
||||
double rp,pp;
|
||||
__asm__ volatile (
|
||||
"1: \n\t"
|
||||
"ldc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"ldc1 %[pp], 0x00(%[prev_row]) \n\t"
|
||||
"paddb %[rp], %[rp], %[pp] \n\t"
|
||||
"sdc1 %[rp], 0x00(%[row]) \n\t"
|
||||
|
||||
"daddiu %[row], %[row], 0x08 \n\t"
|
||||
"daddiu %[prev_row], %[prev_row], 0x08 \n\t"
|
||||
"daddiu %[istop], %[istop], -0x08 \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp)
|
||||
: [row]"r"(row), [prev_row]"r"(prev_row),
|
||||
[istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
}
|
||||
|
||||
void png_read_filter_row_sub3_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev)
|
||||
{
|
||||
int istop = row_info->rowbytes;
|
||||
double rp, pp, dest;
|
||||
double eight, sixteen, twenty_four, forty_eight;
|
||||
double tmp0;
|
||||
double ftmp[2];
|
||||
|
||||
__asm__ volatile (
|
||||
"li %[tmp0], 0x08 \n\t"
|
||||
"dmtc1 %[tmp0], %[eight] \n\t"
|
||||
"li %[tmp0], 0x10 \n\t"
|
||||
"dmtc1 %[tmp0], %[sixteen] \n\t"
|
||||
"li %[tmp0], 0x18 \n\t"
|
||||
"dmtc1 %[tmp0], %[twenty_four] \n\t"
|
||||
"li %[tmp0], 0x30 \n\t"
|
||||
"dmtc1 %[tmp0], %[forty_eight] \n\t"
|
||||
"xor %[dest], %[dest], %[dest] \n\t"
|
||||
|
||||
"1: \n\t"
|
||||
"gsldrc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"gsldlc1 %[rp], 0x07(%[row]) \n\t"
|
||||
"gsldrc1 %[pp], 0x08(%[row]) \n\t"
|
||||
"gsldlc1 %[pp], 0x0f(%[row]) \n\t"
|
||||
|
||||
"paddb %[ftmp0], %[dest], %[rp] \n\t"
|
||||
"swc1 %[ftmp0], 0x00(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp1], %[rp], %[twenty_four] \n\t"
|
||||
"paddb %[dest], %[ftmp1], %[ftmp0] \n\t"
|
||||
"gsswrc1 %[dest], 0x03(%[row]) \n\t"
|
||||
"gsswlc1 %[dest], 0x06(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp], %[forty_eight] \n\t"
|
||||
"dsll %[ftmp1], %[pp], %[sixteen] \n\t"
|
||||
"or %[ftmp0], %[ftmp0], %[ftmp1] \n\t"
|
||||
"paddb %[dest], %[dest], %[ftmp0] \n\t"
|
||||
"gsswrc1 %[dest], 0x06(%[row]) \n\t"
|
||||
"gsswlc1 %[dest], 0x09(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[pp], %[eight] \n\t"
|
||||
"paddb %[dest], %[dest], %[ftmp0] \n\t"
|
||||
"gsswrc1 %[dest], 0x09(%[row]) \n\t"
|
||||
"daddiu %[row], %[row], 0x0c \n\t"
|
||||
"daddiu %[istop], %[istop], -0x0c \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp), [dest]"=&f"(dest),
|
||||
[tmp0]"=&r"(tmp0), [ftmp0]"=&f"(ftmp[0]),
|
||||
[ftmp1]"=&f"(ftmp[1]), [eight]"=&f"(eight),
|
||||
[sixteen]"=&f"(sixteen), [twenty_four]"=&f"(twenty_four),
|
||||
[forty_eight]"=&f"(forty_eight)
|
||||
: [row]"r"(row), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
|
||||
PNG_UNUSED(prev)
|
||||
}
|
||||
|
||||
void png_read_filter_row_sub4_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep 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.
|
||||
*/
|
||||
int istop = row_info->rowbytes;
|
||||
double rp,pp;
|
||||
|
||||
__asm__ volatile (
|
||||
"1: \n\t"
|
||||
"lwc1 %[pp], 0x00(%[row]) \n\t"
|
||||
"lwc1 %[rp], 0x04(%[row]) \n\t"
|
||||
"paddb %[rp], %[rp], %[pp] \n\t"
|
||||
"swc1 %[rp], 0x04(%[row]) \n\t"
|
||||
|
||||
"daddiu %[row], %[row], 0x04 \n\t"
|
||||
"daddiu %[istop], %[istop], -0x04 \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp)
|
||||
: [row]"r"(row), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
|
||||
PNG_UNUSED(prev)
|
||||
}
|
||||
|
||||
void png_read_filter_row_avg3_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev)
|
||||
{
|
||||
int istop = row_info->rowbytes;
|
||||
double rp, pp, rp1, pp1;
|
||||
double tmp0;
|
||||
double ftmp[3];
|
||||
double one, dest;
|
||||
double eight, sixteen, twenty_four, forty_eight;
|
||||
|
||||
__asm__ volatile (
|
||||
"li %[tmp0], 0x08 \n\t"
|
||||
"dmtc1 %[tmp0], %[eight] \n\t"
|
||||
"li %[tmp0], 0x10 \n\t"
|
||||
"dmtc1 %[tmp0], %[sixteen] \n\t"
|
||||
"li %[tmp0], 0x18 \n\t"
|
||||
"dmtc1 %[tmp0], %[twenty_four] \n\t"
|
||||
"li %[tmp0], 0x30 \n\t"
|
||||
"dmtc1 %[tmp0], %[forty_eight] \n\t"
|
||||
"xor %[dest], %[dest], %[dest] \n\t"
|
||||
|
||||
"li %[tmp0], 0x01 \n\t"
|
||||
"ins %[tmp0], %[tmp0], 8, 8 \n\t"
|
||||
"dmtc1 %[tmp0], %[one] \n\t"
|
||||
"pshufh %[one], %[one], %[dest] \n\t"
|
||||
|
||||
"1: \n\t"
|
||||
"gsldrc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"gsldlc1 %[rp], 0x07(%[row]) \n\t"
|
||||
"gsldrc1 %[pp], 0x00(%[prev]) \n\t"
|
||||
"gsldlc1 %[pp], 0x07(%[prev]) \n\t"
|
||||
"gsldrc1 %[rp1], 0x08(%[row]) \n\t"
|
||||
"gsldlc1 %[rp1], 0x0f(%[row]) \n\t"
|
||||
"gsldrc1 %[pp1], 0x08(%[prev]) \n\t"
|
||||
"gsldlc1 %[pp1], 0x0f(%[prev]) \n\t"
|
||||
|
||||
"xor %[ftmp0], %[pp], %[dest] \n\t"
|
||||
"pavgb %[ftmp1], %[pp], %[dest] \n\t"
|
||||
"and %[ftmp0], %[ftmp0], %[one] \n\t"
|
||||
"psubb %[ftmp1], %[ftmp1], %[ftmp0] \n\t"
|
||||
"paddb %[dest], %[rp], %[ftmp1] \n\t"
|
||||
"swc1 %[dest], 0x00(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp], %[twenty_four] \n\t"
|
||||
"dsrl %[ftmp1], %[pp], %[twenty_four] \n\t"
|
||||
|
||||
"xor %[ftmp2], %[ftmp1], %[dest] \n\t"
|
||||
"pavgb %[ftmp1], %[ftmp1], %[dest] \n\t"
|
||||
"and %[ftmp2], %[ftmp2], %[one] \n\t"
|
||||
"psubb %[ftmp1], %[ftmp1], %[ftmp2] \n\t"
|
||||
"paddb %[dest], %[ftmp0], %[ftmp1] \n\t"
|
||||
"gsswrc1 %[dest], 0x03(%[row]) \n\t"
|
||||
"gsswlc1 %[dest], 0x06(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp], %[forty_eight] \n\t"
|
||||
"dsll %[ftmp1], %[rp1], %[sixteen] \n\t"
|
||||
"or %[ftmp0], %[ftmp0], %[ftmp1] \n\t"
|
||||
"dsrl %[ftmp2], %[pp], %[forty_eight] \n\t"
|
||||
"dsll %[ftmp1], %[pp1], %[sixteen] \n\t"
|
||||
"or %[ftmp1], %[ftmp2], %[ftmp1] \n\t"
|
||||
|
||||
"xor %[ftmp2], %[ftmp1], %[dest] \n\t"
|
||||
"pavgb %[ftmp1], %[ftmp1], %[dest] \n\t"
|
||||
"and %[ftmp2], %[ftmp2], %[one] \n\t"
|
||||
"psubb %[ftmp1], %[ftmp1], %[ftmp2] \n\t"
|
||||
"paddb %[dest], %[ftmp0], %[ftmp1] \n\t"
|
||||
"gsswrc1 %[dest], 0x06(%[row]) \n\t"
|
||||
"gsswlc1 %[dest], 0x09(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp1], %[eight] \n\t"
|
||||
"dsrl %[ftmp1], %[pp1], %[eight] \n\t"
|
||||
|
||||
"xor %[ftmp2], %[ftmp1], %[dest] \n\t"
|
||||
"pavgb %[ftmp1], %[ftmp1], %[dest] \n\t"
|
||||
"and %[ftmp2], %[ftmp2], %[one] \n\t"
|
||||
"psubb %[ftmp1], %[ftmp1], %[ftmp2] \n\t"
|
||||
"paddb %[dest], %[ftmp0], %[ftmp1] \n\t"
|
||||
"gsswrc1 %[dest], 0x09(%[row]) \n\t"
|
||||
"daddiu %[row], %[row], 0x0c \n\t"
|
||||
"daddiu %[prev], %[prev], 0x0c \n\t"
|
||||
"daddiu %[istop], %[istop], -0x0c \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp), [rp1]"=&f"(rp1),
|
||||
[pp1]"=&f"(pp1), [tmp0]"=&r"(tmp0), [ftmp0]"=&f"(ftmp[0]),
|
||||
[ftmp1]"=&f"(ftmp[1]), [ftmp2]"=&f"(ftmp[2]), [one]"=&f"(one),
|
||||
[dest]"=&f"(dest), [eight]"=&f"(eight), [sixteen]"=&f"(sixteen),
|
||||
[twenty_four]"=&f"(twenty_four), [forty_eight]"=&f"(forty_eight)
|
||||
: [row]"r"(row), [prev]"r"(prev), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
}
|
||||
|
||||
void png_read_filter_row_avg4_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev)
|
||||
{
|
||||
int istop = row_info->rowbytes;
|
||||
double rp,pp;
|
||||
double dest;
|
||||
double ftmp[2];
|
||||
double tmp;
|
||||
|
||||
__asm__ volatile (
|
||||
"xor %[dest], %[dest], %[dest] \n\t"
|
||||
"li %[tmp], 0x01 \n\t"
|
||||
"ins %[tmp], %[tmp], 8, 8 \n\t"
|
||||
"dmtc1 %[tmp], %[ftmp1] \n\t"
|
||||
"pshufh %[ftmp1], %[ftmp1], %[dest] \n\t"
|
||||
|
||||
"1: \n\t"
|
||||
"lwc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"lwc1 %[pp], 0x00(%[prev]) \n\t"
|
||||
"xor %[ftmp0], %[pp], %[dest] \n\t"
|
||||
"pavgb %[pp], %[pp], %[dest] \n\t"
|
||||
"and %[ftmp0], %[ftmp0], %[ftmp1] \n\t"
|
||||
"psubb %[pp], %[pp], %[ftmp0] \n\t"
|
||||
"paddb %[dest], %[rp], %[pp] \n\t"
|
||||
"swc1 %[dest], 0x00(%[row]) \n\t"
|
||||
"daddiu %[row], %[row], 0x04 \n\t"
|
||||
"daddiu %[prev], %[prev], 0x04 \n\t"
|
||||
"daddiu %[istop], %[istop], -0x04 \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp), [ftmp0]"=&f"(ftmp[0]),
|
||||
[ftmp1]"=&f"(ftmp[1]), [dest]"=&f"(dest), [tmp]"=&r"(tmp)
|
||||
: [row]"r"(row), [prev]"r"(prev), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
}
|
||||
|
||||
void png_read_filter_row_paeth3_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep 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.
|
||||
*/
|
||||
int istop = row_info->rowbytes;
|
||||
double rp, pp, rp1, pp1, zero;
|
||||
double a, b, c, d, pa, pb, pc;
|
||||
double tmp0;
|
||||
double ftmp[3];
|
||||
double eight, sixteen, twenty_four, forty_eight;
|
||||
|
||||
__asm__ volatile (
|
||||
"xor %[a], %[a], %[a] \n\t"
|
||||
"xor %[c], %[c], %[c] \n\t"
|
||||
"xor %[zero], %[zero], %[zero] \n\t"
|
||||
"li %[tmp0], 0x08 \n\t"
|
||||
"dmtc1 %[tmp0], %[eight] \n\t"
|
||||
"li %[tmp0], 0x10 \n\t"
|
||||
"dmtc1 %[tmp0], %[sixteen] \n\t"
|
||||
"li %[tmp0], 0x18 \n\t"
|
||||
"dmtc1 %[tmp0], %[twenty_four] \n\t"
|
||||
"li %[tmp0], 0x30 \n\t"
|
||||
"dmtc1 %[tmp0], %[forty_eight] \n\t"
|
||||
|
||||
"1: \n\t"
|
||||
"gsldrc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"gsldlc1 %[rp], 0x07(%[row]) \n\t"
|
||||
"gsldrc1 %[pp], 0x00(%[prev]) \n\t"
|
||||
"gsldlc1 %[pp], 0x07(%[prev]) \n\t"
|
||||
"gsldrc1 %[rp1], 0x08(%[row]) \n\t"
|
||||
"gsldlc1 %[rp1], 0x0f(%[row]) \n\t"
|
||||
"gsldrc1 %[pp1], 0x08(%[prev]) \n\t"
|
||||
"gsldlc1 %[pp1], 0x0f(%[prev]) \n\t"
|
||||
|
||||
"punpcklbh %[b], %[pp], %[zero] \n\t"
|
||||
"punpcklbh %[d], %[rp], %[zero] \n\t"
|
||||
"packushb %[ftmp0], %[c], %[c] \n\t"
|
||||
"packushb %[ftmp1], %[a], %[a] \n\t"
|
||||
"pasubub %[pa], %[pp], %[ftmp0] \n\t"
|
||||
"pasubub %[pb], %[ftmp1], %[ftmp0] \n\t"
|
||||
"psubh %[ftmp0], %[b], %[c] \n\t"
|
||||
"psubh %[ftmp1], %[a], %[c] \n\t"
|
||||
"paddh %[pc], %[ftmp0], %[ftmp1] \n\t"
|
||||
"pcmpgth %[ftmp0], %[zero], %[pc] \n\t"
|
||||
"xor %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"psubh %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"punpcklbh %[pa], %[pa], %[zero] \n\t"
|
||||
"punpcklbh %[pb], %[pb], %[zero] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pb] \n\t"
|
||||
"and %[ftmp1], %[b], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"pminsh %[pa], %[pa], %[pb] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pc] \n\t"
|
||||
"and %[ftmp1], %[c], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"paddb %[a], %[a], %[d] \n\t"
|
||||
"packushb %[d], %[a], %[a] \n\t"
|
||||
"punpcklbh %[c], %[pp], %[zero] \n\t"
|
||||
"swc1 %[d], 0x00(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp], %[twenty_four] \n\t"
|
||||
"dsrl %[ftmp2], %[pp], %[twenty_four] \n\t"
|
||||
|
||||
"punpcklbh %[b], %[ftmp2], %[zero] \n\t"
|
||||
"punpcklbh %[d], %[ftmp0], %[zero] \n\t"
|
||||
"packushb %[ftmp0], %[c], %[c] \n\t"
|
||||
"packushb %[ftmp1], %[a], %[a] \n\t"
|
||||
"pasubub %[pa], %[ftmp2], %[ftmp0] \n\t"
|
||||
"pasubub %[pb], %[ftmp1], %[ftmp0] \n\t"
|
||||
"psubh %[ftmp0], %[b], %[c] \n\t"
|
||||
"psubh %[ftmp1], %[a], %[c] \n\t"
|
||||
"paddh %[pc], %[ftmp0], %[ftmp1] \n\t"
|
||||
"pcmpgth %[ftmp0], %[zero], %[pc] \n\t"
|
||||
"xor %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"psubh %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"punpcklbh %[pa], %[pa], %[zero] \n\t"
|
||||
"punpcklbh %[pb], %[pb], %[zero] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pb] \n\t"
|
||||
"and %[ftmp1], %[b], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"pminsh %[pa], %[pa], %[pb] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pc] \n\t"
|
||||
"and %[ftmp1], %[c], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"paddb %[a], %[a], %[d] \n\t"
|
||||
"packushb %[d], %[a], %[a] \n\t"
|
||||
"punpcklbh %[c], %[ftmp2], %[zero] \n\t"
|
||||
"gsswrc1 %[d], 0x03(%[row]) \n\t"
|
||||
"gsswlc1 %[d], 0x06(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp], %[forty_eight] \n\t"
|
||||
"dsll %[ftmp1], %[rp1], %[sixteen] \n\t"
|
||||
"or %[ftmp0], %[ftmp0], %[ftmp1] \n\t"
|
||||
"dsrl %[ftmp2], %[pp], %[forty_eight] \n\t"
|
||||
"dsll %[ftmp1], %[pp1], %[sixteen] \n\t"
|
||||
"or %[ftmp2], %[ftmp2], %[ftmp1] \n\t"
|
||||
|
||||
"punpcklbh %[b], %[ftmp2], %[zero] \n\t"
|
||||
"punpcklbh %[d], %[ftmp0], %[zero] \n\t"
|
||||
"packushb %[ftmp0], %[c], %[c] \n\t"
|
||||
"packushb %[ftmp1], %[a], %[a] \n\t"
|
||||
"pasubub %[pa], %[ftmp2], %[ftmp0] \n\t"
|
||||
"pasubub %[pb], %[ftmp1], %[ftmp0] \n\t"
|
||||
"psubh %[ftmp0], %[b], %[c] \n\t"
|
||||
"psubh %[ftmp1], %[a], %[c] \n\t"
|
||||
"paddh %[pc], %[ftmp0], %[ftmp1] \n\t"
|
||||
"pcmpgth %[ftmp0], %[zero], %[pc] \n\t"
|
||||
"xor %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"psubh %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"punpcklbh %[pa], %[pa], %[zero] \n\t"
|
||||
"punpcklbh %[pb], %[pb], %[zero] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pb] \n\t"
|
||||
"and %[ftmp1], %[b], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"pminsh %[pa], %[pa], %[pb] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pc] \n\t"
|
||||
"and %[ftmp1], %[c], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"paddb %[a], %[a], %[d] \n\t"
|
||||
"packushb %[d], %[a], %[a] \n\t"
|
||||
"punpcklbh %[c], %[ftmp2], %[zero] \n\t"
|
||||
"gsswrc1 %[d], 0x06(%[row]) \n\t"
|
||||
"gsswlc1 %[d], 0x09(%[row]) \n\t"
|
||||
|
||||
"dsrl %[ftmp0], %[rp1], %[eight] \n\t"
|
||||
"dsrl %[ftmp2], %[pp1], %[eight] \n\t"
|
||||
|
||||
"punpcklbh %[b], %[ftmp2], %[zero] \n\t"
|
||||
"punpcklbh %[d], %[ftmp0], %[zero] \n\t"
|
||||
"packushb %[ftmp0], %[c], %[c] \n\t"
|
||||
"packushb %[ftmp1], %[a], %[a] \n\t"
|
||||
"pasubub %[pa], %[ftmp2], %[ftmp0] \n\t"
|
||||
"pasubub %[pb], %[ftmp1], %[ftmp0] \n\t"
|
||||
"psubh %[ftmp0], %[b], %[c] \n\t"
|
||||
"psubh %[ftmp1], %[a], %[c] \n\t"
|
||||
"paddh %[pc], %[ftmp0], %[ftmp1] \n\t"
|
||||
"pcmpgth %[ftmp0], %[zero], %[pc] \n\t"
|
||||
"xor %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"psubh %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"punpcklbh %[pa], %[pa], %[zero] \n\t"
|
||||
"punpcklbh %[pb], %[pb], %[zero] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pb] \n\t"
|
||||
"and %[ftmp1], %[b], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"pminsh %[pa], %[pa], %[pb] \n\t"
|
||||
"pcmpgth %[ftmp0], %[pa], %[pc] \n\t"
|
||||
"and %[ftmp1], %[c], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"paddb %[a], %[a], %[d] \n\t"
|
||||
"packushb %[d], %[a], %[a] \n\t"
|
||||
"punpcklbh %[c], %[ftmp2], %[zero] \n\t"
|
||||
"gsswrc1 %[d], 0x09(%[row]) \n\t"
|
||||
|
||||
"daddiu %[row], %[row], 0x0c \n\t"
|
||||
"daddiu %[prev], %[prev], 0x0c \n\t"
|
||||
"daddiu %[istop], %[istop], -0x0c \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp), [rp1]"=&f"(rp1), [pp1]"=&f"(pp1),
|
||||
[zero]"=&f"(zero), [a]"=&f"(a),[b]"=&f"(b), [c]"=&f"(c),
|
||||
[d]"=&f"(d), [pa]"=&f"(pa), [pb]"=&f"(pb), [pc]"=&f"(pc),
|
||||
[tmp0]"=&r"(tmp0), [ftmp0]"=&f"(ftmp[0]), [ftmp1]"=&f"(ftmp[1]),
|
||||
[ftmp2]"=&f"(ftmp[2]), [eight]"=&f"(eight), [sixteen]"=&f"(sixteen),
|
||||
[twenty_four]"=&f"(twenty_four), [forty_eight]"=&f"(forty_eight)
|
||||
: [row]"r"(row), [prev]"r"(prev), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
}
|
||||
|
||||
void png_read_filter_row_paeth4_mmi(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep 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.
|
||||
*/
|
||||
int istop = row_info->rowbytes;
|
||||
double rp, pp, zero;
|
||||
double a, b, c, d, pa, pb, pc;
|
||||
double ftmp[2];
|
||||
|
||||
__asm__ volatile (
|
||||
"xor %[a], %[a], %[a] \n\t"
|
||||
"xor %[c], %[c], %[c] \n\t"
|
||||
"xor %[zero], %[zero], %[zero] \n\t"
|
||||
|
||||
"1: \n\t"
|
||||
"lwc1 %[rp], 0x00(%[row]) \n\t"
|
||||
"lwc1 %[pp], 0x00(%[prev]) \n\t"
|
||||
"punpcklbh %[b], %[pp], %[zero] \n\t"
|
||||
"punpcklbh %[d], %[rp], %[zero] \n\t"
|
||||
|
||||
"packushb %[ftmp0], %[c], %[c] \n\t"
|
||||
"packushb %[ftmp1], %[a], %[a] \n\t"
|
||||
"pasubub %[pa], %[pp], %[ftmp0] \n\t"
|
||||
"pasubub %[pb], %[ftmp1], %[ftmp0] \n\t"
|
||||
"psubh %[ftmp0], %[b], %[c] \n\t"
|
||||
"psubh %[ftmp1], %[a], %[c] \n\t"
|
||||
"paddh %[pc], %[ftmp0], %[ftmp1] \n\t"
|
||||
"pcmpgth %[ftmp0], %[zero], %[pc] \n\t"
|
||||
"xor %[pc], %[pc], %[ftmp0] \n\t"
|
||||
"psubh %[pc], %[pc], %[ftmp0] \n\t"
|
||||
|
||||
"punpcklbh %[pa], %[pa], %[zero] \n\t"
|
||||
"punpcklbh %[pb], %[pb], %[zero] \n\t"
|
||||
|
||||
"pcmpgth %[ftmp0], %[pa], %[pb] \n\t"
|
||||
"and %[ftmp1], %[b], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"pminsh %[pa], %[pa], %[pb] \n\t"
|
||||
|
||||
"pcmpgth %[ftmp0], %[pa], %[pc] \n\t"
|
||||
"and %[ftmp1], %[c], %[ftmp0] \n\t"
|
||||
"pandn %[a], %[ftmp0], %[a] \n\t"
|
||||
"or %[a], %[a], %[ftmp1] \n\t"
|
||||
"paddb %[a], %[a], %[d] \n\t"
|
||||
"packushb %[d], %[a], %[a] \n\t"
|
||||
"swc1 %[d], 0x00(%[row]) \n\t"
|
||||
"punpcklbh %[c], %[pp], %[zero] \n\t"
|
||||
"daddiu %[row], %[row], 0x04 \n\t"
|
||||
"daddiu %[prev], %[prev], 0x04 \n\t"
|
||||
"daddiu %[istop], %[istop], -0x04 \n\t"
|
||||
"bgtz %[istop], 1b \n\t"
|
||||
: [rp]"=&f"(rp), [pp]"=&f"(pp), [zero]"=&f"(zero),
|
||||
[a]"=&f"(a), [b]"=&f"(b), [c]"=&f"(c), [d]"=&f"(d),
|
||||
[pa]"=&f"(pa), [pb]"=&f"(pb), [pc]"=&f"(pc),
|
||||
[ftmp0]"=&f"(ftmp[0]), [ftmp1]"=&f"(ftmp[1])
|
||||
: [row]"r"(row), [prev]"r"(prev), [istop]"r"(istop)
|
||||
: "memory"
|
||||
);
|
||||
}
|
||||
|
||||
#endif /* PNG_MIPS_MMI_IMPLEMENTATION > 0 */
|
||||
#endif /* READ */
|
||||
+812
@@ -0,0 +1,812 @@
|
||||
/* filter_msa_intrinsics.c - MSA optimised filter functions
|
||||
*
|
||||
* Copyright (c) 2018-2024 Cosmin Truta
|
||||
* Copyright (c) 2016 Glenn Randers-Pehrson
|
||||
* Written by Mandar Sahastrabuddhe, August 2016
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "../pngpriv.h"
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
|
||||
/* This code requires -mfpu=msa on the command line: */
|
||||
#if PNG_MIPS_MSA_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
|
||||
|
||||
#include <msa.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* libpng row pointers are not necessarily aligned to any particular boundary,
|
||||
* however this code will only work with appropriate alignment. mips/mips_init.c
|
||||
* checks for this (and will not compile unless it is done). This code uses
|
||||
* variants of png_aligncast to avoid compiler warnings.
|
||||
*/
|
||||
#define png_ptr(type,pointer) png_aligncast(type *,pointer)
|
||||
#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer)
|
||||
|
||||
/* The following relies on a variable 'temp_pointer' being declared with type
|
||||
* 'type'. This is written this way just to hide the GCC strict aliasing
|
||||
* warning; note that the code is safe because there never is an alias between
|
||||
* the input and output pointers.
|
||||
*/
|
||||
#define png_ldr(type,pointer)\
|
||||
(temp_pointer = png_ptr(type,pointer), *temp_pointer)
|
||||
|
||||
#if PNG_MIPS_MSA_OPT > 0
|
||||
|
||||
#ifdef CLANG_BUILD
|
||||
#define MSA_SRLI_B(a, b) __msa_srli_b((v16i8) a, b)
|
||||
|
||||
#define LW(psrc) \
|
||||
( { \
|
||||
uint8_t *psrc_lw_m = (uint8_t *) (psrc); \
|
||||
uint32_t val_m; \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"lw %[val_m], %[psrc_lw_m] \n\t" \
|
||||
\
|
||||
: [val_m] "=r" (val_m) \
|
||||
: [psrc_lw_m] "m" (*psrc_lw_m) \
|
||||
); \
|
||||
\
|
||||
val_m; \
|
||||
} )
|
||||
|
||||
#define SH(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sh_m = (uint8_t *) (pdst); \
|
||||
uint16_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sh %[val_m], %[pdst_sh_m] \n\t" \
|
||||
\
|
||||
: [pdst_sh_m] "=m" (*pdst_sh_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#define SW(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sw_m = (uint8_t *) (pdst); \
|
||||
uint32_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sw %[val_m], %[pdst_sw_m] \n\t" \
|
||||
\
|
||||
: [pdst_sw_m] "=m" (*pdst_sw_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#if __mips == 64
|
||||
#define SD(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sd_m = (uint8_t *) (pdst); \
|
||||
uint64_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sd %[val_m], %[pdst_sd_m] \n\t" \
|
||||
\
|
||||
: [pdst_sd_m] "=m" (*pdst_sd_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
#else
|
||||
#define SD(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sd_m = (uint8_t *) (pdst); \
|
||||
uint32_t val0_m, val1_m; \
|
||||
\
|
||||
val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF); \
|
||||
val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF); \
|
||||
\
|
||||
SW(val0_m, pdst_sd_m); \
|
||||
SW(val1_m, pdst_sd_m + 4); \
|
||||
}
|
||||
#endif /* __mips == 64 */
|
||||
#else
|
||||
#define MSA_SRLI_B(a, b) (a >> b)
|
||||
|
||||
#if __mips_isa_rev >= 6
|
||||
#define LW(psrc) \
|
||||
( { \
|
||||
uint8_t *psrc_lw_m = (uint8_t *) (psrc); \
|
||||
uint32_t val_m; \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"lw %[val_m], %[psrc_lw_m] \n\t" \
|
||||
\
|
||||
: [val_m] "=r" (val_m) \
|
||||
: [psrc_lw_m] "m" (*psrc_lw_m) \
|
||||
); \
|
||||
\
|
||||
val_m; \
|
||||
} )
|
||||
|
||||
#define SH(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sh_m = (uint8_t *) (pdst); \
|
||||
uint16_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sh %[val_m], %[pdst_sh_m] \n\t" \
|
||||
\
|
||||
: [pdst_sh_m] "=m" (*pdst_sh_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#define SW(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sw_m = (uint8_t *) (pdst); \
|
||||
uint32_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sw %[val_m], %[pdst_sw_m] \n\t" \
|
||||
\
|
||||
: [pdst_sw_m] "=m" (*pdst_sw_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#if __mips == 64
|
||||
#define SD(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sd_m = (uint8_t *) (pdst); \
|
||||
uint64_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"sd %[val_m], %[pdst_sd_m] \n\t" \
|
||||
\
|
||||
: [pdst_sd_m] "=m" (*pdst_sd_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
#else
|
||||
#define SD(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sd_m = (uint8_t *) (pdst); \
|
||||
uint32_t val0_m, val1_m; \
|
||||
\
|
||||
val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF); \
|
||||
val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF); \
|
||||
\
|
||||
SW(val0_m, pdst_sd_m); \
|
||||
SW(val1_m, pdst_sd_m + 4); \
|
||||
}
|
||||
#endif /* __mips == 64 */
|
||||
#else
|
||||
#define LW(psrc) \
|
||||
( { \
|
||||
uint8_t *psrc_lw_m = (uint8_t *) (psrc); \
|
||||
uint32_t val_m; \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"ulw %[val_m], %[psrc_lw_m] \n\t" \
|
||||
\
|
||||
: [val_m] "=r" (val_m) \
|
||||
: [psrc_lw_m] "m" (*psrc_lw_m) \
|
||||
); \
|
||||
\
|
||||
val_m; \
|
||||
} )
|
||||
|
||||
#define SH(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sh_m = (uint8_t *) (pdst); \
|
||||
uint16_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"ush %[val_m], %[pdst_sh_m] \n\t" \
|
||||
\
|
||||
: [pdst_sh_m] "=m" (*pdst_sh_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#define SW(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sw_m = (uint8_t *) (pdst); \
|
||||
uint32_t val_m = (val); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"usw %[val_m], %[pdst_sw_m] \n\t" \
|
||||
\
|
||||
: [pdst_sw_m] "=m" (*pdst_sw_m) \
|
||||
: [val_m] "r" (val_m) \
|
||||
); \
|
||||
}
|
||||
|
||||
#define SD(val, pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_sd_m = (uint8_t *) (pdst); \
|
||||
uint32_t val0_m, val1_m; \
|
||||
\
|
||||
val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF); \
|
||||
val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF); \
|
||||
\
|
||||
SW(val0_m, pdst_sd_m); \
|
||||
SW(val1_m, pdst_sd_m + 4); \
|
||||
}
|
||||
|
||||
#define SW_ZERO(pdst) \
|
||||
{ \
|
||||
uint8_t *pdst_m = (uint8_t *) (pdst); \
|
||||
\
|
||||
__asm__ volatile ( \
|
||||
"usw $0, %[pdst_m] \n\t" \
|
||||
\
|
||||
: [pdst_m] "=m" (*pdst_m) \
|
||||
: \
|
||||
); \
|
||||
}
|
||||
#endif /* __mips_isa_rev >= 6 */
|
||||
#endif
|
||||
|
||||
#define LD_B(RTYPE, psrc) *((RTYPE *) (psrc))
|
||||
#define LD_UB(...) LD_B(v16u8, __VA_ARGS__)
|
||||
#define LD_B2(RTYPE, psrc, stride, out0, out1) \
|
||||
{ \
|
||||
out0 = LD_B(RTYPE, (psrc)); \
|
||||
out1 = LD_B(RTYPE, (psrc) + stride); \
|
||||
}
|
||||
#define LD_UB2(...) LD_B2(v16u8, __VA_ARGS__)
|
||||
#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3) \
|
||||
{ \
|
||||
LD_B2(RTYPE, (psrc), stride, out0, out1); \
|
||||
LD_B2(RTYPE, (psrc) + 2 * stride , stride, out2, out3); \
|
||||
}
|
||||
#define LD_UB4(...) LD_B4(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ST_B(RTYPE, in, pdst) *((RTYPE *) (pdst)) = (in)
|
||||
#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
|
||||
#define ST_B2(RTYPE, in0, in1, pdst, stride) \
|
||||
{ \
|
||||
ST_B(RTYPE, in0, (pdst)); \
|
||||
ST_B(RTYPE, in1, (pdst) + stride); \
|
||||
}
|
||||
#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
|
||||
#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride) \
|
||||
{ \
|
||||
ST_B2(RTYPE, in0, in1, (pdst), stride); \
|
||||
ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride); \
|
||||
}
|
||||
#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ADD2(in0, in1, in2, in3, out0, out1) \
|
||||
{ \
|
||||
out0 = in0 + in1; \
|
||||
out1 = in2 + in3; \
|
||||
}
|
||||
#define ADD3(in0, in1, in2, in3, in4, in5, \
|
||||
out0, out1, out2) \
|
||||
{ \
|
||||
ADD2(in0, in1, in2, in3, out0, out1); \
|
||||
out2 = in4 + in5; \
|
||||
}
|
||||
#define ADD4(in0, in1, in2, in3, in4, in5, in6, in7, \
|
||||
out0, out1, out2, out3) \
|
||||
{ \
|
||||
ADD2(in0, in1, in2, in3, out0, out1); \
|
||||
ADD2(in4, in5, in6, in7, out2, out3); \
|
||||
}
|
||||
|
||||
#define ILVR_B2(RTYPE, in0, in1, in2, in3, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE) __msa_ilvr_b((v16i8) in0, (v16i8) in1); \
|
||||
out1 = (RTYPE) __msa_ilvr_b((v16i8) in2, (v16i8) in3); \
|
||||
}
|
||||
#define ILVR_B2_SH(...) ILVR_B2(v8i16, __VA_ARGS__)
|
||||
|
||||
#define HSUB_UB2(RTYPE, in0, in1, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE) __msa_hsub_u_h((v16u8) in0, (v16u8) in0); \
|
||||
out1 = (RTYPE) __msa_hsub_u_h((v16u8) in1, (v16u8) in1); \
|
||||
}
|
||||
#define HSUB_UB2_SH(...) HSUB_UB2(v8i16, __VA_ARGS__)
|
||||
|
||||
#define SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val) \
|
||||
{ \
|
||||
v16i8 zero_m = { 0 }; \
|
||||
out0 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in0, slide_val); \
|
||||
out1 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in1, slide_val); \
|
||||
}
|
||||
#define SLDI_B2_0_UB(...) SLDI_B2_0(v16u8, __VA_ARGS__)
|
||||
|
||||
#define SLDI_B3_0(RTYPE, in0, in1, in2, out0, out1, out2, slide_val) \
|
||||
{ \
|
||||
v16i8 zero_m = { 0 }; \
|
||||
SLDI_B2_0(RTYPE, in0, in1, out0, out1, slide_val); \
|
||||
out2 = (RTYPE) __msa_sldi_b((v16i8) zero_m, (v16i8) in2, slide_val); \
|
||||
}
|
||||
#define SLDI_B3_0_UB(...) SLDI_B3_0(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ILVEV_W2(RTYPE, in0, in1, in2, in3, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE) __msa_ilvev_w((v4i32) in1, (v4i32) in0); \
|
||||
out1 = (RTYPE) __msa_ilvev_w((v4i32) in3, (v4i32) in2); \
|
||||
}
|
||||
#define ILVEV_W2_UB(...) ILVEV_W2(v16u8, __VA_ARGS__)
|
||||
|
||||
#define ADD_ABS_H3(RTYPE, in0, in1, in2, out0, out1, out2) \
|
||||
{ \
|
||||
RTYPE zero = {0}; \
|
||||
\
|
||||
out0 = __msa_add_a_h((v8i16) zero, in0); \
|
||||
out1 = __msa_add_a_h((v8i16) zero, in1); \
|
||||
out2 = __msa_add_a_h((v8i16) zero, in2); \
|
||||
}
|
||||
#define ADD_ABS_H3_SH(...) ADD_ABS_H3(v8i16, __VA_ARGS__)
|
||||
|
||||
#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1) \
|
||||
{ \
|
||||
out0 = (RTYPE) __msa_vshf_b((v16i8) mask0, (v16i8) in1, (v16i8) in0); \
|
||||
out1 = (RTYPE) __msa_vshf_b((v16i8) mask1, (v16i8) in3, (v16i8) in2); \
|
||||
}
|
||||
#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
|
||||
|
||||
#define CMP_AND_SELECT(inp0, inp1, inp2, inp3, inp4, inp5, out0) \
|
||||
{ \
|
||||
v8i16 _sel_h0, _sel_h1; \
|
||||
v16u8 _sel_b0, _sel_b1; \
|
||||
_sel_h0 = (v8i16) __msa_clt_u_h((v8u16) inp1, (v8u16) inp0); \
|
||||
_sel_b0 = (v16u8) __msa_pckev_b((v16i8) _sel_h0, (v16i8) _sel_h0); \
|
||||
inp0 = (v8i16) __msa_bmnz_v((v16u8) inp0, (v16u8) inp1, (v16u8) _sel_h0); \
|
||||
inp4 = (v16u8) __msa_bmnz_v(inp3, inp4, _sel_b0); \
|
||||
_sel_h1 = (v8i16) __msa_clt_u_h((v8u16) inp2, (v8u16) inp0); \
|
||||
_sel_b1 = (v16u8) __msa_pckev_b((v16i8) _sel_h1, (v16i8) _sel_h1); \
|
||||
inp4 = (v16u8) __msa_bmnz_v(inp4, inp5, _sel_b1); \
|
||||
out0 += inp4; \
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_up_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
size_t i, cnt, cnt16, cnt32;
|
||||
size_t istop = row_info->rowbytes;
|
||||
png_bytep rp = row;
|
||||
png_const_bytep pp = prev_row;
|
||||
v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
|
||||
|
||||
for (i = 0; i < (istop >> 6); i++)
|
||||
{
|
||||
LD_UB4(rp, 16, src0, src1, src2, src3);
|
||||
LD_UB4(pp, 16, src4, src5, src6, src7);
|
||||
pp += 64;
|
||||
|
||||
ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
|
||||
src0, src1, src2, src3);
|
||||
|
||||
ST_UB4(src0, src1, src2, src3, rp, 16);
|
||||
rp += 64;
|
||||
}
|
||||
|
||||
if (istop & 0x3F)
|
||||
{
|
||||
cnt32 = istop & 0x20;
|
||||
cnt16 = istop & 0x10;
|
||||
cnt = istop & 0xF;
|
||||
|
||||
if(cnt32)
|
||||
{
|
||||
if (cnt16 && cnt)
|
||||
{
|
||||
LD_UB4(rp, 16, src0, src1, src2, src3);
|
||||
LD_UB4(pp, 16, src4, src5, src6, src7);
|
||||
|
||||
ADD4(src0, src4, src1, src5, src2, src6, src3, src7,
|
||||
src0, src1, src2, src3);
|
||||
|
||||
ST_UB4(src0, src1, src2, src3, rp, 16);
|
||||
rp += 64;
|
||||
}
|
||||
else if (cnt16 || cnt)
|
||||
{
|
||||
LD_UB2(rp, 16, src0, src1);
|
||||
LD_UB2(pp, 16, src4, src5);
|
||||
pp += 32;
|
||||
src2 = LD_UB(rp + 32);
|
||||
src6 = LD_UB(pp);
|
||||
|
||||
ADD3(src0, src4, src1, src5, src2, src6, src0, src1, src2);
|
||||
|
||||
ST_UB2(src0, src1, rp, 16);
|
||||
rp += 32;
|
||||
ST_UB(src2, rp);
|
||||
rp += 16;
|
||||
}
|
||||
else
|
||||
{
|
||||
LD_UB2(rp, 16, src0, src1);
|
||||
LD_UB2(pp, 16, src4, src5);
|
||||
|
||||
ADD2(src0, src4, src1, src5, src0, src1);
|
||||
|
||||
ST_UB2(src0, src1, rp, 16);
|
||||
rp += 32;
|
||||
}
|
||||
}
|
||||
else if (cnt16 && cnt)
|
||||
{
|
||||
LD_UB2(rp, 16, src0, src1);
|
||||
LD_UB2(pp, 16, src4, src5);
|
||||
|
||||
ADD2(src0, src4, src1, src5, src0, src1);
|
||||
|
||||
ST_UB2(src0, src1, rp, 16);
|
||||
rp += 32;
|
||||
}
|
||||
else if (cnt16 || cnt)
|
||||
{
|
||||
src0 = LD_UB(rp);
|
||||
src4 = LD_UB(pp);
|
||||
pp += 16;
|
||||
|
||||
src0 += src4;
|
||||
|
||||
ST_UB(src0, rp);
|
||||
rp += 16;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_sub4_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
size_t count;
|
||||
size_t istop = row_info->rowbytes;
|
||||
png_bytep src = row;
|
||||
png_bytep nxt = row + 4;
|
||||
int32_t inp0;
|
||||
v16u8 src0, src1, src2, src3, src4;
|
||||
v16u8 dst0, dst1;
|
||||
v16u8 zero = { 0 };
|
||||
|
||||
istop -= 4;
|
||||
|
||||
inp0 = LW(src);
|
||||
src += 4;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
|
||||
for (count = 0; count < istop; count += 16)
|
||||
{
|
||||
src1 = LD_UB(src);
|
||||
src += 16;
|
||||
|
||||
src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 4);
|
||||
src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 8);
|
||||
src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 12);
|
||||
src1 += src0;
|
||||
src2 += src1;
|
||||
src3 += src2;
|
||||
src4 += src3;
|
||||
src0 = src4;
|
||||
ILVEV_W2_UB(src1, src2, src3, src4, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
|
||||
|
||||
ST_UB(dst0, nxt);
|
||||
nxt += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_sub3_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
size_t count;
|
||||
size_t istop = row_info->rowbytes;
|
||||
png_bytep src = row;
|
||||
png_bytep nxt = row + 3;
|
||||
int64_t out0;
|
||||
int32_t inp0, out1;
|
||||
v16u8 src0, src1, src2, src3, src4, dst0, dst1;
|
||||
v16u8 zero = { 0 };
|
||||
v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
|
||||
|
||||
istop -= 3;
|
||||
|
||||
inp0 = LW(src);
|
||||
src += 3;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
|
||||
for (count = 0; count < istop; count += 12)
|
||||
{
|
||||
src1 = LD_UB(src);
|
||||
src += 12;
|
||||
|
||||
src2 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 3);
|
||||
src3 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 6);
|
||||
src4 = (v16u8) __msa_sldi_b((v16i8) zero, (v16i8) src1, 9);
|
||||
src1 += src0;
|
||||
src2 += src1;
|
||||
src3 += src2;
|
||||
src4 += src3;
|
||||
src0 = src4;
|
||||
VSHF_B2_UB(src1, src2, src3, src4, mask0, mask0, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
|
||||
out0 = __msa_copy_s_d((v2i64) dst0, 0);
|
||||
out1 = __msa_copy_s_w((v4i32) dst0, 2);
|
||||
|
||||
SD(out0, nxt);
|
||||
nxt += 8;
|
||||
SW(out1, nxt);
|
||||
nxt += 4;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_avg4_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
size_t i;
|
||||
png_bytep src = row;
|
||||
png_bytep nxt = row;
|
||||
png_const_bytep pp = prev_row;
|
||||
size_t istop = row_info->rowbytes - 4;
|
||||
int32_t inp0, inp1, out0;
|
||||
v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
|
||||
v16u8 zero = { 0 };
|
||||
|
||||
inp0 = LW(pp);
|
||||
pp += 4;
|
||||
inp1 = LW(src);
|
||||
src += 4;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
|
||||
src0 = (v16u8) MSA_SRLI_B(src0, 1);
|
||||
src1 += src0;
|
||||
out0 = __msa_copy_s_w((v4i32) src1, 0);
|
||||
SW(out0, nxt);
|
||||
nxt += 4;
|
||||
|
||||
for (i = 0; i < istop; i += 16)
|
||||
{
|
||||
src2 = LD_UB(pp);
|
||||
pp += 16;
|
||||
src6 = LD_UB(src);
|
||||
src += 16;
|
||||
|
||||
SLDI_B2_0_UB(src2, src6, src3, src7, 4);
|
||||
SLDI_B2_0_UB(src2, src6, src4, src8, 8);
|
||||
SLDI_B2_0_UB(src2, src6, src5, src9, 12);
|
||||
src2 = __msa_ave_u_b(src2, src1);
|
||||
src6 += src2;
|
||||
src3 = __msa_ave_u_b(src3, src6);
|
||||
src7 += src3;
|
||||
src4 = __msa_ave_u_b(src4, src7);
|
||||
src8 += src4;
|
||||
src5 = __msa_ave_u_b(src5, src8);
|
||||
src9 += src5;
|
||||
src1 = src9;
|
||||
ILVEV_W2_UB(src6, src7, src8, src9, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
|
||||
|
||||
ST_UB(dst0, nxt);
|
||||
nxt += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_avg3_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
size_t i;
|
||||
png_bytep src = row;
|
||||
png_bytep nxt = row;
|
||||
png_const_bytep pp = prev_row;
|
||||
size_t istop = row_info->rowbytes - 3;
|
||||
int64_t out0;
|
||||
int32_t inp0, inp1, out1;
|
||||
int16_t out2;
|
||||
v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
|
||||
v16u8 zero = { 0 };
|
||||
v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
|
||||
|
||||
inp0 = LW(pp);
|
||||
pp += 3;
|
||||
inp1 = LW(src);
|
||||
src += 3;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
|
||||
src0 = (v16u8) MSA_SRLI_B(src0, 1);
|
||||
src1 += src0;
|
||||
out2 = __msa_copy_s_h((v8i16) src1, 0);
|
||||
SH(out2, nxt);
|
||||
nxt += 2;
|
||||
nxt[0] = src1[2];
|
||||
nxt++;
|
||||
|
||||
for (i = 0; i < istop; i += 12)
|
||||
{
|
||||
src2 = LD_UB(pp);
|
||||
pp += 12;
|
||||
src6 = LD_UB(src);
|
||||
src += 12;
|
||||
|
||||
SLDI_B2_0_UB(src2, src6, src3, src7, 3);
|
||||
SLDI_B2_0_UB(src2, src6, src4, src8, 6);
|
||||
SLDI_B2_0_UB(src2, src6, src5, src9, 9);
|
||||
src2 = __msa_ave_u_b(src2, src1);
|
||||
src6 += src2;
|
||||
src3 = __msa_ave_u_b(src3, src6);
|
||||
src7 += src3;
|
||||
src4 = __msa_ave_u_b(src4, src7);
|
||||
src8 += src4;
|
||||
src5 = __msa_ave_u_b(src5, src8);
|
||||
src9 += src5;
|
||||
src1 = src9;
|
||||
VSHF_B2_UB(src6, src7, src8, src9, mask0, mask0, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
|
||||
out0 = __msa_copy_s_d((v2i64) dst0, 0);
|
||||
out1 = __msa_copy_s_w((v4i32) dst0, 2);
|
||||
|
||||
SD(out0, nxt);
|
||||
nxt += 8;
|
||||
SW(out1, nxt);
|
||||
nxt += 4;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_paeth4_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
int32_t count, rp_end;
|
||||
png_bytep nxt;
|
||||
png_const_bytep prev_nxt;
|
||||
int32_t inp0, inp1, res0;
|
||||
v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
|
||||
v16u8 src10, src11, src12, src13, dst0, dst1;
|
||||
v8i16 vec0, vec1, vec2;
|
||||
v16u8 zero = { 0 };
|
||||
|
||||
nxt = row;
|
||||
prev_nxt = prev_row;
|
||||
|
||||
inp0 = LW(nxt);
|
||||
inp1 = LW(prev_nxt);
|
||||
prev_nxt += 4;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
|
||||
|
||||
src1 += src0;
|
||||
res0 = __msa_copy_s_w((v4i32) src1, 0);
|
||||
|
||||
SW(res0, nxt);
|
||||
nxt += 4;
|
||||
|
||||
/* Remainder */
|
||||
rp_end = row_info->rowbytes - 4;
|
||||
|
||||
for (count = 0; count < rp_end; count += 16)
|
||||
{
|
||||
src2 = LD_UB(prev_nxt);
|
||||
prev_nxt += 16;
|
||||
src6 = LD_UB(prev_row);
|
||||
prev_row += 16;
|
||||
src10 = LD_UB(nxt);
|
||||
|
||||
SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 4);
|
||||
SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 8);
|
||||
SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 12);
|
||||
ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
|
||||
ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
|
||||
ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
|
||||
ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
|
||||
src1 = src13;
|
||||
ILVEV_W2_UB(src10, src11, src12, src1, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
|
||||
|
||||
ST_UB(dst0, nxt);
|
||||
nxt += 16;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
png_read_filter_row_paeth3_msa(png_row_infop row_info, png_bytep row,
|
||||
png_const_bytep prev_row)
|
||||
{
|
||||
int32_t count, rp_end;
|
||||
png_bytep nxt;
|
||||
png_const_bytep prev_nxt;
|
||||
int64_t out0;
|
||||
int32_t inp0, inp1, out1;
|
||||
int16_t out2;
|
||||
v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, dst0, dst1;
|
||||
v16u8 src10, src11, src12, src13;
|
||||
v8i16 vec0, vec1, vec2;
|
||||
v16u8 zero = { 0 };
|
||||
v16i8 mask0 = { 0, 1, 2, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
v16i8 mask1 = { 0, 1, 2, 3, 4, 5, 16, 17, 18, 19, 20, 21, 0, 0, 0, 0 };
|
||||
|
||||
nxt = row;
|
||||
prev_nxt = prev_row;
|
||||
|
||||
inp0 = LW(nxt);
|
||||
inp1 = LW(prev_nxt);
|
||||
prev_nxt += 3;
|
||||
src0 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp0);
|
||||
src1 = (v16u8) __msa_insert_w((v4i32) zero, 0, inp1);
|
||||
|
||||
src1 += src0;
|
||||
out2 = __msa_copy_s_h((v8i16) src1, 0);
|
||||
|
||||
SH(out2, nxt);
|
||||
nxt += 2;
|
||||
nxt[0] = src1[2];
|
||||
nxt++;
|
||||
|
||||
/* Remainder */
|
||||
rp_end = row_info->rowbytes - 3;
|
||||
|
||||
for (count = 0; count < rp_end; count += 12)
|
||||
{
|
||||
src2 = LD_UB(prev_nxt);
|
||||
prev_nxt += 12;
|
||||
src6 = LD_UB(prev_row);
|
||||
prev_row += 12;
|
||||
src10 = LD_UB(nxt);
|
||||
|
||||
SLDI_B3_0_UB(src2, src6, src10, src3, src7, src11, 3);
|
||||
SLDI_B3_0_UB(src2, src6, src10, src4, src8, src12, 6);
|
||||
SLDI_B3_0_UB(src2, src6, src10, src5, src9, src13, 9);
|
||||
ILVR_B2_SH(src2, src6, src1, src6, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src1, src2, src6, src10);
|
||||
ILVR_B2_SH(src3, src7, src10, src7, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src10, src3, src7, src11);
|
||||
ILVR_B2_SH(src4, src8, src11, src8, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src11, src4, src8, src12);
|
||||
ILVR_B2_SH(src5, src9, src12, src9, vec0, vec1);
|
||||
HSUB_UB2_SH(vec0, vec1, vec0, vec1);
|
||||
vec2 = vec0 + vec1;
|
||||
ADD_ABS_H3_SH(vec0, vec1, vec2, vec0, vec1, vec2);
|
||||
CMP_AND_SELECT(vec0, vec1, vec2, src12, src5, src9, src13);
|
||||
src1 = src13;
|
||||
VSHF_B2_UB(src10, src11, src12, src13, mask0, mask0, dst0, dst1);
|
||||
dst0 = (v16u8) __msa_vshf_b(mask1, (v16i8) dst1, (v16i8) dst0);
|
||||
out0 = __msa_copy_s_d((v2i64) dst0, 0);
|
||||
out1 = __msa_copy_s_w((v4i32) dst0, 2);
|
||||
|
||||
SD(out0, nxt);
|
||||
nxt += 8;
|
||||
SW(out1, nxt);
|
||||
nxt += 4;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PNG_MIPS_MSA_OPT > 0 */
|
||||
#endif /* PNG_MIPS_MSA_IMPLEMENTATION == 1 (intrinsics) */
|
||||
#endif /* READ */
|
||||
Vendored
+203
@@ -0,0 +1,203 @@
|
||||
/* mips_init.c - MSA optimised filter functions
|
||||
*
|
||||
* Copyright (c) 2018-2024 Cosmin Truta
|
||||
* Copyright (c) 2016 Glenn Randers-Pehrson
|
||||
* Written by Mandar Sahastrabuddhe, 2016
|
||||
* Updated by guxiwei, 2023
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*/
|
||||
|
||||
/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
|
||||
* called.
|
||||
*/
|
||||
#define _POSIX_SOURCE 1
|
||||
|
||||
#include <stdio.h>
|
||||
#include "../pngpriv.h"
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
|
||||
#if PNG_MIPS_MSA_IMPLEMENTATION == 1 || PNG_MIPS_MMI_IMPLEMENTATION > 0
|
||||
|
||||
#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED /* Do MIPS MSA run-time checks */
|
||||
/* WARNING: it is strongly recommended that you do not build libpng with
|
||||
* run-time checks for CPU features if at all possible. In the case of the MIPS
|
||||
* MSA instructions there is no processor-specific way of detecting the
|
||||
* presence of the required support, therefore run-time detection is extremely
|
||||
* OS specific.
|
||||
*
|
||||
* You may set the macro PNG_MIPS_MSA_FILE to the file name of file containing
|
||||
* a fragment of C source code which defines the png_have_msa function. There
|
||||
* are a number of implementations in contrib/mips-msa, but the only one that
|
||||
* has partial support is contrib/mips-msa/linux.c - a generic Linux
|
||||
* implementation which reads /proc/cpufino.
|
||||
*/
|
||||
#ifndef PNG_MIPS_MSA_FILE
|
||||
# ifdef __linux__
|
||||
# define PNG_MIPS_MSA_FILE "contrib/mips-msa/linux.c"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef PNG_MIPS_MSA_FILE
|
||||
|
||||
#include <signal.h> /* for sig_atomic_t */
|
||||
static int png_have_msa(png_structp png_ptr);
|
||||
#include PNG_MIPS_MSA_FILE
|
||||
|
||||
#else /* PNG_MIPS_MSA_FILE */
|
||||
# error PNG_MIPS_MSA_FILE undefined: no support for run-time MIPS MSA checks
|
||||
#endif /* PNG_MIPS_MSA_FILE */
|
||||
#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
|
||||
|
||||
#ifdef PNG_MIPS_MMI_CHECK_SUPPORTED /* Do MIPS MMI run-times checks */
|
||||
#ifndef PNG_MIPS_MMI_FILE
|
||||
# ifdef __linux__
|
||||
# define PNG_MIPS_MMI_FILE "contrib/mips-mmi/linux.c"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef PNG_MIPS_MMI_FILE
|
||||
|
||||
#include <signal.h> /* for sig_atomic_t */
|
||||
static int png_have_mmi();
|
||||
#include PNG_MIPS_MMI_FILE
|
||||
|
||||
#else /* PNG_MIPS_MMI_FILE */
|
||||
# error PNG_MIPS_MMI_FILE undefined: no support for run-time MIPS MMI checks
|
||||
#endif /* PNG_MIPS_MMI_FILE */
|
||||
#endif /* PNG_MIPS_MMI_CHECK_SUPPORTED*/
|
||||
|
||||
#ifndef PNG_ALIGNED_MEMORY_SUPPORTED
|
||||
# error ALIGNED_MEMORY is required; please define PNG_ALIGNED_MEMORY_SUPPORTED
|
||||
#endif
|
||||
|
||||
/* MIPS supports two optimizations: MMI and MSA. The appropriate
|
||||
* optimization is chosen at runtime
|
||||
*/
|
||||
void
|
||||
png_init_filter_functions_mips(png_structp pp, unsigned int bpp)
|
||||
{
|
||||
#if PNG_MIPS_MMI_IMPLEMENTATION > 0
|
||||
#ifdef PNG_MIPS_MMI_API_SUPPORTED
|
||||
switch ((pp->options >> PNG_MIPS_MMI) & 3)
|
||||
{
|
||||
case PNG_OPTION_UNSET:
|
||||
#endif /* PNG_MIPS_MMI_API_SUPPORTED */
|
||||
#ifdef PNG_MIPS_MMI_CHECK_SUPPORTED
|
||||
{
|
||||
static volatile sig_atomic_t no_mmi = -1; /* not checked */
|
||||
|
||||
if (no_mmi < 0)
|
||||
no_mmi = !png_have_mmi();
|
||||
|
||||
if (no_mmi)
|
||||
goto MIPS_MSA_INIT;
|
||||
}
|
||||
#ifdef PNG_MIPS_MMI_API_SUPPORTED
|
||||
break;
|
||||
#endif
|
||||
#endif /* PNG_MIPS_MMI_CHECK_SUPPORTED */
|
||||
|
||||
#ifdef PNG_MIPS_MMI_API_SUPPORTED
|
||||
default: /* OFF or INVALID */
|
||||
goto MIPS_MSA_INIT;
|
||||
|
||||
case PNG_OPTION_ON:
|
||||
/* Option turned on */
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_mmi;
|
||||
if (bpp == 3)
|
||||
{
|
||||
pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_mmi;
|
||||
pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_mmi;
|
||||
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
|
||||
png_read_filter_row_paeth3_mmi;
|
||||
}
|
||||
else if (bpp == 4)
|
||||
{
|
||||
pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_mmi;
|
||||
pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_mmi;
|
||||
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
|
||||
png_read_filter_row_paeth4_mmi;
|
||||
}
|
||||
#endif /* PNG_MIPS_MMI_IMPLEMENTATION > 0 */
|
||||
|
||||
MIPS_MSA_INIT:
|
||||
#if PNG_MIPS_MSA_IMPLEMENTATION == 1
|
||||
/* The switch statement is compiled in for MIPS_MSA_API, the call to
|
||||
* png_have_msa is compiled in for MIPS_MSA_CHECK. If both are defined
|
||||
* the check is only performed if the API has not set the MSA option on
|
||||
* or off explicitly. In this case the check controls what happens.
|
||||
*/
|
||||
|
||||
#ifdef PNG_MIPS_MSA_API_SUPPORTED
|
||||
switch ((pp->options >> PNG_MIPS_MSA) & 3)
|
||||
{
|
||||
case PNG_OPTION_UNSET:
|
||||
/* Allow the run-time check to execute if it has been enabled -
|
||||
* thus both API and CHECK can be turned on. If it isn't supported
|
||||
* this case will fall through to the 'default' below, which just
|
||||
* returns.
|
||||
*/
|
||||
#endif /* PNG_MIPS_MSA_API_SUPPORTED */
|
||||
#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
|
||||
{
|
||||
static volatile sig_atomic_t no_msa = -1; /* not checked */
|
||||
|
||||
if (no_msa < 0)
|
||||
no_msa = !png_have_msa(pp);
|
||||
|
||||
if (no_msa)
|
||||
return;
|
||||
}
|
||||
#ifdef PNG_MIPS_MSA_API_SUPPORTED
|
||||
break;
|
||||
#endif
|
||||
#endif /* PNG_MIPS_MSA_CHECK_SUPPORTED */
|
||||
|
||||
#ifdef PNG_MIPS_MSA_API_SUPPORTED
|
||||
default: /* OFF or INVALID */
|
||||
return;
|
||||
|
||||
case PNG_OPTION_ON:
|
||||
/* Option turned on */
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* IMPORTANT: any new external functions used here must be declared using
|
||||
* PNG_INTERNAL_FUNCTION in ../pngpriv.h. This is required so that the
|
||||
* 'prefix' option to configure works:
|
||||
*
|
||||
* ./configure --with-libpng-prefix=foobar_
|
||||
*
|
||||
* Verify you have got this right by running the above command, doing a build
|
||||
* and examining pngprefix.h; it must contain a #define for every external
|
||||
* function you add. (Notice that this happens automatically for the
|
||||
* initialization function.)
|
||||
*/
|
||||
pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_msa;
|
||||
|
||||
if (bpp == 3)
|
||||
{
|
||||
pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_msa;
|
||||
pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_msa;
|
||||
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_msa;
|
||||
}
|
||||
|
||||
else if (bpp == 4)
|
||||
{
|
||||
pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_msa;
|
||||
pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_msa;
|
||||
pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_msa;
|
||||
}
|
||||
#endif /* PNG_MIPS_MSA_IMPLEMENTATION == 1 */
|
||||
return;
|
||||
}
|
||||
#endif /* PNG_MIPS_MSA_IMPLEMENTATION == 1 || PNG_MIPS_MMI_IMPLEMENTATION > 0 */
|
||||
#endif /* READ */
|
||||
Reference in New Issue
Block a user