• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2016 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // MSA variant of methods for lossless decoder
11 //
12 // Author: Prashant Patil (prashant.patil@imgtec.com)
13 
14 #include "src/dsp/dsp.h"
15 
16 #if defined(WEBP_USE_MSA)
17 
18 #include "src/dsp/lossless.h"
19 #include "src/dsp/msa_macro.h"
20 
21 //------------------------------------------------------------------------------
22 // Colorspace conversion functions
23 
24 #define CONVERT16_BGRA_XXX(psrc, pdst, m0, m1, m2) do {    \
25   v16u8 src0, src1, src2, src3, dst0, dst1, dst2;          \
26   LD_UB4(psrc, 16, src0, src1, src2, src3);                \
27   VSHF_B2_UB(src0, src1, src1, src2, m0, m1, dst0, dst1);  \
28   dst2 = VSHF_UB(src2, src3, m2);                          \
29   ST_UB2(dst0, dst1, pdst, 16);                            \
30   ST_UB(dst2, pdst + 32);                                  \
31 } while (0)
32 
33 #define CONVERT12_BGRA_XXX(psrc, pdst, m0, m1, m2) do {    \
34   uint32_t pix_w;                                          \
35   v16u8 src0, src1, src2, dst0, dst1, dst2;                \
36   LD_UB3(psrc, 16, src0, src1, src2);                      \
37   VSHF_B2_UB(src0, src1, src1, src2, m0, m1, dst0, dst1);  \
38   dst2 = VSHF_UB(src2, src2, m2);                          \
39   ST_UB2(dst0, dst1, pdst, 16);                            \
40   pix_w = __msa_copy_s_w((v4i32)dst2, 0);                  \
41   SW(pix_w, pdst + 32);                                    \
42 } while (0)
43 
44 #define CONVERT8_BGRA_XXX(psrc, pdst, m0, m1) do {         \
45   uint64_t pix_d;                                          \
46   v16u8 src0, src1, src2 = { 0 }, dst0, dst1;              \
47   LD_UB2(psrc, 16, src0, src1);                            \
48   VSHF_B2_UB(src0, src1, src1, src2, m0, m1, dst0, dst1);  \
49   ST_UB(dst0, pdst);                                       \
50   pix_d = __msa_copy_s_d((v2i64)dst1, 0);                  \
51   SD(pix_d, pdst + 16);                                    \
52 } while (0)
53 
54 #define CONVERT4_BGRA_XXX(psrc, pdst, m) do {       \
55   const v16u8 src0 = LD_UB(psrc);                   \
56   const v16u8 dst0 = VSHF_UB(src0, src0, m);        \
57   uint64_t pix_d = __msa_copy_s_d((v2i64)dst0, 0);  \
58   uint32_t pix_w = __msa_copy_s_w((v4i32)dst0, 2);  \
59   SD(pix_d, pdst + 0);                              \
60   SW(pix_w, pdst + 8);                              \
61 } while (0)
62 
63 #define CONVERT1_BGRA_BGR(psrc, pdst) do {  \
64   const int32_t b = (psrc)[0];              \
65   const int32_t g = (psrc)[1];              \
66   const int32_t r = (psrc)[2];              \
67   (pdst)[0] = b;                            \
68   (pdst)[1] = g;                            \
69   (pdst)[2] = r;                            \
70 } while (0)
71 
72 #define CONVERT1_BGRA_RGB(psrc, pdst) do {  \
73   const int32_t b = (psrc)[0];              \
74   const int32_t g = (psrc)[1];              \
75   const int32_t r = (psrc)[2];              \
76   (pdst)[0] = r;                            \
77   (pdst)[1] = g;                            \
78   (pdst)[2] = b;                            \
79 } while (0)
80 
81 #define TRANSFORM_COLOR_INVERSE_8(src0, src1, dst0, dst1,     \
82                                   c0, c1, mask0, mask1) do {  \
83   v8i16 g0, g1, t0, t1, t2, t3;                               \
84   v4i32 t4, t5;                                               \
85   VSHF_B2_SH(src0, src0, src1, src1, mask0, mask0, g0, g1);   \
86   DOTP_SB2_SH(g0, g1, c0, c0, t0, t1);                        \
87   SRAI_H2_SH(t0, t1, 5);                                      \
88   t0 = __msa_addv_h(t0, (v8i16)src0);                         \
89   t1 = __msa_addv_h(t1, (v8i16)src1);                         \
90   t4 = __msa_srli_w((v4i32)t0, 16);                           \
91   t5 = __msa_srli_w((v4i32)t1, 16);                           \
92   DOTP_SB2_SH(t4, t5, c1, c1, t2, t3);                        \
93   SRAI_H2_SH(t2, t3, 5);                                      \
94   ADD2(t0, t2, t1, t3, t0, t1);                               \
95   VSHF_B2_UB(src0, t0, src1, t1, mask1, mask1, dst0, dst1);   \
96 } while (0)
97 
98 #define TRANSFORM_COLOR_INVERSE_4(src, dst, c0, c1, mask0, mask1) do {  \
99   const v16i8 g0 = VSHF_SB(src, src, mask0);                            \
100   v8i16 t0 = __msa_dotp_s_h(c0, g0);                                    \
101   v8i16 t1;                                                             \
102   v4i32 t2;                                                             \
103   t0 = SRAI_H(t0, 5);                                                   \
104   t0 = __msa_addv_h(t0, (v8i16)src);                                    \
105   t2 = __msa_srli_w((v4i32)t0, 16);                                     \
106   t1 = __msa_dotp_s_h(c1, (v16i8)t2);                                   \
107   t1 = SRAI_H(t1, 5);                                                   \
108   t0 = t0 + t1;                                                         \
109   dst = VSHF_UB(src, t0, mask1);                                        \
110 } while (0)
111 
ConvertBGRAToRGBA_MSA(const uint32_t * src,int num_pixels,uint8_t * dst)112 static void ConvertBGRAToRGBA_MSA(const uint32_t* src,
113                                   int num_pixels, uint8_t* dst) {
114   int i;
115   const uint8_t* ptemp_src = (const uint8_t*)src;
116   uint8_t* ptemp_dst = (uint8_t*)dst;
117   v16u8 src0, dst0;
118   const v16u8 mask = { 2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8, 11, 14, 13, 12, 15 };
119 
120   while (num_pixels >= 8) {
121     v16u8 src1, dst1;
122     LD_UB2(ptemp_src, 16, src0, src1);
123     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, dst0, dst1);
124     ST_UB2(dst0, dst1, ptemp_dst, 16);
125     ptemp_src += 32;
126     ptemp_dst += 32;
127     num_pixels -= 8;
128   }
129   if (num_pixels > 0) {
130     if (num_pixels >= 4) {
131       src0 = LD_UB(ptemp_src);
132       dst0 = VSHF_UB(src0, src0, mask);
133       ST_UB(dst0, ptemp_dst);
134       ptemp_src += 16;
135       ptemp_dst += 16;
136       num_pixels -= 4;
137     }
138     for (i = 0; i < num_pixels; i++) {
139       const uint8_t b = ptemp_src[2];
140       const uint8_t g = ptemp_src[1];
141       const uint8_t r = ptemp_src[0];
142       const uint8_t a = ptemp_src[3];
143       ptemp_dst[0] = b;
144       ptemp_dst[1] = g;
145       ptemp_dst[2] = r;
146       ptemp_dst[3] = a;
147       ptemp_src += 4;
148       ptemp_dst += 4;
149     }
150   }
151 }
152 
ConvertBGRAToBGR_MSA(const uint32_t * src,int num_pixels,uint8_t * dst)153 static void ConvertBGRAToBGR_MSA(const uint32_t* src,
154                                  int num_pixels, uint8_t* dst) {
155   const uint8_t* ptemp_src = (const uint8_t*)src;
156   uint8_t* ptemp_dst = (uint8_t*)dst;
157   const v16u8 mask0 = { 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14,
158                         16, 17, 18, 20 };
159   const v16u8 mask1 = { 5, 6, 8, 9, 10, 12, 13, 14, 16, 17, 18, 20,
160                         21, 22, 24, 25 };
161   const v16u8 mask2 = { 10, 12, 13, 14, 16, 17, 18, 20, 21, 22, 24, 25,
162                         26, 28, 29, 30 };
163 
164   while (num_pixels >= 16) {
165     CONVERT16_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1, mask2);
166     ptemp_src += 64;
167     ptemp_dst += 48;
168     num_pixels -= 16;
169   }
170   if (num_pixels > 0) {
171     if (num_pixels >= 12) {
172       CONVERT12_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1, mask2);
173       ptemp_src += 48;
174       ptemp_dst += 36;
175       num_pixels -= 12;
176     } else if (num_pixels >= 8) {
177       CONVERT8_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1);
178       ptemp_src += 32;
179       ptemp_dst += 24;
180       num_pixels -= 8;
181     } else if (num_pixels >= 4) {
182       CONVERT4_BGRA_XXX(ptemp_src, ptemp_dst, mask0);
183       ptemp_src += 16;
184       ptemp_dst += 12;
185       num_pixels -= 4;
186     }
187     if (num_pixels == 3) {
188       CONVERT1_BGRA_BGR(ptemp_src + 0, ptemp_dst + 0);
189       CONVERT1_BGRA_BGR(ptemp_src + 4, ptemp_dst + 3);
190       CONVERT1_BGRA_BGR(ptemp_src + 8, ptemp_dst + 6);
191     } else if (num_pixels == 2) {
192       CONVERT1_BGRA_BGR(ptemp_src + 0, ptemp_dst + 0);
193       CONVERT1_BGRA_BGR(ptemp_src + 4, ptemp_dst + 3);
194     } else if (num_pixels == 1) {
195       CONVERT1_BGRA_BGR(ptemp_src, ptemp_dst);
196     }
197   }
198 }
199 
ConvertBGRAToRGB_MSA(const uint32_t * src,int num_pixels,uint8_t * dst)200 static void ConvertBGRAToRGB_MSA(const uint32_t* src,
201                                  int num_pixels, uint8_t* dst) {
202   const uint8_t* ptemp_src = (const uint8_t*)src;
203   uint8_t* ptemp_dst = (uint8_t*)dst;
204   const v16u8 mask0 = { 2, 1, 0, 6, 5, 4, 10, 9, 8, 14, 13, 12,
205                         18, 17, 16, 22 };
206   const v16u8 mask1 = { 5, 4, 10, 9, 8, 14, 13, 12, 18, 17, 16, 22,
207                         21, 20, 26, 25 };
208   const v16u8 mask2 = { 8, 14, 13, 12, 18, 17, 16, 22, 21, 20, 26, 25,
209                         24, 30, 29, 28 };
210 
211   while (num_pixels >= 16) {
212     CONVERT16_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1, mask2);
213     ptemp_src += 64;
214     ptemp_dst += 48;
215     num_pixels -= 16;
216   }
217   if (num_pixels) {
218     if (num_pixels >= 12) {
219       CONVERT12_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1, mask2);
220       ptemp_src += 48;
221       ptemp_dst += 36;
222       num_pixels -= 12;
223     } else if (num_pixels >= 8) {
224       CONVERT8_BGRA_XXX(ptemp_src, ptemp_dst, mask0, mask1);
225       ptemp_src += 32;
226       ptemp_dst += 24;
227       num_pixels -= 8;
228     } else if (num_pixels >= 4) {
229       CONVERT4_BGRA_XXX(ptemp_src, ptemp_dst, mask0);
230       ptemp_src += 16;
231       ptemp_dst += 12;
232       num_pixels -= 4;
233     }
234     if (num_pixels == 3) {
235       CONVERT1_BGRA_RGB(ptemp_src + 0, ptemp_dst + 0);
236       CONVERT1_BGRA_RGB(ptemp_src + 4, ptemp_dst + 3);
237       CONVERT1_BGRA_RGB(ptemp_src + 8, ptemp_dst + 6);
238     } else if (num_pixels == 2) {
239       CONVERT1_BGRA_RGB(ptemp_src + 0, ptemp_dst + 0);
240       CONVERT1_BGRA_RGB(ptemp_src + 4, ptemp_dst + 3);
241     } else if (num_pixels == 1) {
242       CONVERT1_BGRA_RGB(ptemp_src, ptemp_dst);
243     }
244   }
245 }
246 
AddGreenToBlueAndRed_MSA(const uint32_t * const src,int num_pixels,uint32_t * dst)247 static void AddGreenToBlueAndRed_MSA(const uint32_t* const src, int num_pixels,
248                                      uint32_t* dst) {
249   int i;
250   const uint8_t* in = (const uint8_t*)src;
251   uint8_t* out = (uint8_t*)dst;
252   v16u8 src0, dst0, tmp0;
253   const v16u8 mask = { 1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255,
254                        13, 255, 13, 255 };
255 
256   while (num_pixels >= 8) {
257     v16u8 src1, dst1, tmp1;
258     LD_UB2(in, 16, src0, src1);
259     VSHF_B2_UB(src0, src1, src1, src0, mask, mask, tmp0, tmp1);
260     ADD2(src0, tmp0, src1, tmp1, dst0, dst1);
261     ST_UB2(dst0, dst1, out, 16);
262     in += 32;
263     out += 32;
264     num_pixels -= 8;
265   }
266   if (num_pixels > 0) {
267     if (num_pixels >= 4) {
268       src0 = LD_UB(in);
269       tmp0 = VSHF_UB(src0, src0, mask);
270       dst0 = src0 + tmp0;
271       ST_UB(dst0, out);
272       in += 16;
273       out += 16;
274       num_pixels -= 4;
275     }
276     for (i = 0; i < num_pixels; i++) {
277       const uint8_t b = in[0];
278       const uint8_t g = in[1];
279       const uint8_t r = in[2];
280       out[0] = (b + g) & 0xff;
281       out[1] = g;
282       out[2] = (r + g) & 0xff;
283       out[4] = in[4];
284       out += 4;
285     }
286   }
287 }
288 
TransformColorInverse_MSA(const VP8LMultipliers * const m,const uint32_t * src,int num_pixels,uint32_t * dst)289 static void TransformColorInverse_MSA(const VP8LMultipliers* const m,
290                                       const uint32_t* src, int num_pixels,
291                                       uint32_t* dst) {
292   v16u8 src0, dst0;
293   const v16i8 g2br = (v16i8)__msa_fill_w(m->green_to_blue_ |
294                                          (m->green_to_red_ << 16));
295   const v16i8 r2b = (v16i8)__msa_fill_w(m->red_to_blue_);
296   const v16u8 mask0 = { 1, 255, 1, 255, 5, 255, 5, 255, 9, 255, 9, 255,
297                         13, 255, 13, 255 };
298   const v16u8 mask1 = { 16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11,
299                         28, 13, 30, 15 };
300 
301   while (num_pixels >= 8) {
302     v16u8 src1, dst1;
303     LD_UB2(src, 4, src0, src1);
304     TRANSFORM_COLOR_INVERSE_8(src0, src1, dst0, dst1, g2br, r2b, mask0, mask1);
305     ST_UB2(dst0, dst1, dst, 4);
306     src += 8;
307     dst += 8;
308     num_pixels -= 8;
309   }
310   if (num_pixels > 0) {
311     if (num_pixels >= 4) {
312       src0 = LD_UB(src);
313       TRANSFORM_COLOR_INVERSE_4(src0, dst0, g2br, r2b, mask0, mask1);
314       ST_UB(dst0, dst);
315       src += 4;
316       dst += 4;
317       num_pixels -= 4;
318     }
319     if (num_pixels > 0) {
320       src0 = LD_UB(src);
321       TRANSFORM_COLOR_INVERSE_4(src0, dst0, g2br, r2b, mask0, mask1);
322       if (num_pixels == 3) {
323         const uint64_t pix_d = __msa_copy_s_d((v2i64)dst0, 0);
324         const uint32_t pix_w = __msa_copy_s_w((v4i32)dst0, 2);
325         SD(pix_d, dst + 0);
326         SW(pix_w, dst + 2);
327       } else if (num_pixels == 2) {
328         const uint64_t pix_d = __msa_copy_s_d((v2i64)dst0, 0);
329         SD(pix_d, dst);
330       } else {
331         const uint32_t pix_w = __msa_copy_s_w((v4i32)dst0, 0);
332         SW(pix_w, dst);
333       }
334     }
335   }
336 }
337 
338 //------------------------------------------------------------------------------
339 // Entry point
340 
341 extern void VP8LDspInitMSA(void);
342 
VP8LDspInitMSA(void)343 WEBP_TSAN_IGNORE_FUNCTION void VP8LDspInitMSA(void) {
344   VP8LConvertBGRAToRGBA = ConvertBGRAToRGBA_MSA;
345   VP8LConvertBGRAToBGR = ConvertBGRAToBGR_MSA;
346   VP8LConvertBGRAToRGB = ConvertBGRAToRGB_MSA;
347 
348   VP8LAddGreenToBlueAndRed = AddGreenToBlueAndRed_MSA;
349   VP8LTransformColorInverse = TransformColorInverse_MSA;
350 }
351 
352 #else  // !WEBP_USE_MSA
353 
354 WEBP_DSP_INIT_STUB(VP8LDspInitMSA)
355 
356 #endif  // WEBP_USE_MSA
357