PPC64: Add versions of functions in libswscale/input.c optimized for POWER8 VSX SIMD.
[ffmpeg.git] / libswscale / ppc / input_vsx.c
1 /*
2  * Copyright (C) 2016 Dan Parrot <dan.parrot@mail.com>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <math.h>
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #include "libavutil/avutil.h"
27 #include "libavutil/bswap.h"
28 #include "libavutil/cpu.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/avassert.h"
33 #include "config.h"
34 #include "libswscale/rgb2rgb.h"
35 #include "libswscale/swscale.h"
36 #include "libswscale/swscale_internal.h"
37
38 #if HAVE_VSX
39
40 static void abgrToA_c_vsx(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
41                           int width, uint32_t *unused)
42 {
43     int16_t *dst = (int16_t *)_dst;
44     int i, width_adj, frag_len;
45
46     uintptr_t src_addr = (uintptr_t)src;
47     uintptr_t dst_addr = (uintptr_t)dst;
48
49     // compute integral number of vector-length items and length of final fragment
50     width_adj = width >> 3;
51     width_adj = width_adj << 3;
52     frag_len = width - width_adj;
53
54     for ( i = 0; i < width_adj; i += 8) {
55         vector int v_rd0 = vec_vsx_ld(0, (int *)src_addr);
56         vector int v_rd1 = vec_vsx_ld(0, (int *)(src_addr + 16));
57
58         v_rd0 = vec_and(v_rd0, vec_splats(0x0ff));
59         v_rd1 = vec_and(v_rd1, vec_splats(0x0ff));
60
61         v_rd0 = vec_sl(v_rd0, vec_splats((unsigned)6));
62         v_rd1 = vec_sl(v_rd1, vec_splats((unsigned)6));
63
64         vector int v_dst = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
65                                                    {0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29}));
66         vec_vsx_st((vector unsigned char)v_dst, 0, (unsigned char *)dst_addr);
67
68         src_addr += 32;
69         dst_addr += 16;
70     }
71
72     for (i=width_adj; i< width_adj + frag_len; i++) {
73         dst[i]= src[4*i]<<6;
74     }
75 }
76
77 static void rgbaToA_c_vsx(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
78                           int width, uint32_t *unused)
79 {
80     int16_t *dst = (int16_t *)_dst;
81     int i, width_adj, frag_len;
82
83     uintptr_t src_addr = (uintptr_t)src;
84     uintptr_t dst_addr = (uintptr_t)dst;
85
86     // compute integral number of vector-length items and length of final fragment
87     width_adj = width >> 3;
88     width_adj = width_adj << 3;
89     frag_len = width - width_adj;
90
91     for ( i = 0; i < width_adj; i += 8) {
92         vector int v_rd0 = vec_vsx_ld(0, (int *)src_addr);
93         vector int v_rd1 = vec_vsx_ld(0, (int *)(src_addr + 16));
94
95         v_rd0 = vec_sld(v_rd0, v_rd0, 13);
96         v_rd1 = vec_sld(v_rd1, v_rd1, 13);
97
98         v_rd0 = vec_and(v_rd0, vec_splats(0x0ff));
99         v_rd1 = vec_and(v_rd1, vec_splats(0x0ff));
100
101         v_rd0 = vec_sl(v_rd0, vec_splats((unsigned)6));
102         v_rd1 = vec_sl(v_rd1, vec_splats((unsigned)6));
103
104         vector int v_dst = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
105                                                    {0, 1, 4, 5, 8, 9, 12, 13, 16, 17, 20, 21, 24, 25, 28, 29}));
106         vec_vsx_st((vector unsigned char)v_dst, 0, (unsigned char *)dst_addr);
107
108         src_addr += 32;
109         dst_addr += 16;
110     }
111
112     for (i=width_adj; i< width_adj + frag_len; i++) {
113         dst[i]= src[4*i+3]<<6;
114     }
115 }
116
117 static void yuy2ToY_c_vsx(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
118                           uint32_t *unused)
119 {
120     int i, width_adj, frag_len;
121
122     uintptr_t src_addr = (uintptr_t)src;
123     uintptr_t dst_addr = (uintptr_t)dst;
124
125     // compute integral number of vector-length items and length of final fragment
126     width_adj = width >> 4;
127     width_adj = width_adj << 4;
128     frag_len = width - width_adj;
129
130     for ( i = 0; i < width_adj; i += 16) {
131         vector unsigned char v_rd0 = vec_vsx_ld(0, (unsigned char *)src_addr);
132         vector unsigned char v_rd1 = vec_vsx_ld(0, (unsigned char *)(src_addr + 16));
133
134         vector unsigned char v_dst = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
135                                                              {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}));
136         vec_vsx_st((vector unsigned char)v_dst, 0, (unsigned char *)dst_addr);
137
138         src_addr += 32;
139         dst_addr += 16;
140     }
141
142     for (i=width_adj; i< width_adj + frag_len; i++) {
143         dst[i] = src[2 * i];
144     }
145 }
146
147 static void yuy2ToUV_c_vsx(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
148                            const uint8_t *src2, int width, uint32_t *unused)
149 {
150     int i, width_adj, frag_len;
151
152     uintptr_t src1_addr = (uintptr_t)src1;
153     uintptr_t dstu_addr = (uintptr_t)dstU;
154     uintptr_t dstv_addr = (uintptr_t)dstV;
155
156     // compute integral number of vector-length items and length of final fragment
157     width_adj = width >> 4;
158     width_adj = width_adj << 4;
159     frag_len = width - width_adj;
160
161     for ( i = 0; i < width_adj; i += 16) {
162         vector unsigned char v_src1_0 = vec_vsx_ld(0, (unsigned char *)src1_addr);
163         vector unsigned char v_src1_1 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 16));
164         vector unsigned char v_src1_2 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 32));
165         vector unsigned char v_src1_3 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 48));
166
167         vector unsigned char v_dstu = vec_perm(v_src1_0, v_src1_1,
168                                               ((vector unsigned char)
169                                                {1, 5, 9, 13, 17, 21, 25, 29, 1, 5, 9, 13, 17, 21, 25, 29}));
170         vector unsigned char v_dstv = vec_perm(v_src1_0, v_src1_1,
171                                               ((vector unsigned char)
172                                                {3, 7, 11, 15, 19, 23, 27, 31, 1, 5, 9, 13, 17, 21, 25, 29}));
173
174         v_dstu = vec_perm(v_dstu, v_src1_2,((vector unsigned char)
175                                             {0, 1, 2, 3, 4, 5, 6, 7, 17, 21, 25, 29, 17, 21, 25, 29}));
176         v_dstv = vec_perm(v_dstv, v_src1_2,((vector unsigned char)
177                                             {0, 1, 2, 3, 4, 5, 6, 7, 19, 23, 27, 31, 17, 21, 25, 29}));
178
179         v_dstu = vec_perm(v_dstu, v_src1_3,((vector unsigned char)
180                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25, 29}));
181         v_dstv = vec_perm(v_dstv, v_src1_3,((vector unsigned char)
182                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 19, 23, 27, 31}));
183
184         vec_vsx_st((vector unsigned char)v_dstu, 0, (unsigned char *)dstu_addr);
185         vec_vsx_st((vector unsigned char)v_dstv, 0, (unsigned char *)dstv_addr);
186
187         src1_addr += 64;
188         dstu_addr += 16;
189         dstv_addr += 16;
190     }
191
192     for (i=width_adj; i< width_adj + frag_len; i++) {
193         dstU[i] = src1[4 * i + 1];
194         dstV[i] = src1[4 * i + 3];
195     }
196     av_assert1(src1 == src2);
197 }
198
199 static void yvy2ToUV_c_vsx(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
200                            const uint8_t *src2, int width, uint32_t *unused)
201 {
202     int i, width_adj, frag_len;
203
204     uintptr_t src1_addr = (uintptr_t)src1;
205     uintptr_t dstu_addr = (uintptr_t)dstU;
206     uintptr_t dstv_addr = (uintptr_t)dstV;
207
208     // compute integral number of vector-length items and length of final fragment
209     width_adj = width >> 4;
210     width_adj = width_adj << 4;
211     frag_len = width - width_adj;
212
213     for ( i = 0; i < width_adj; i += 16) {
214         vector unsigned char v_src1_0 = vec_vsx_ld(0, (unsigned char *)src1_addr);
215         vector unsigned char v_src1_1 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 16));
216         vector unsigned char v_src1_2 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 32));
217         vector unsigned char v_src1_3 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 48));
218
219         vector unsigned char v_dstv = vec_perm(v_src1_0, v_src1_1,
220                                               ((vector unsigned char)
221                                                {1, 5, 9, 13, 17, 21, 25, 29, 1, 5, 9, 13, 17, 21, 25, 29}));
222         vector unsigned char v_dstu = vec_perm(v_src1_0, v_src1_1,
223                                               ((vector unsigned char)
224                                                {3, 7, 11, 15, 19, 23, 27, 31, 1, 5, 9, 13, 17, 21, 25, 29}));
225
226         v_dstv = vec_perm(v_dstv, v_src1_2,((vector unsigned char)
227                                             {0, 1, 2, 3, 4, 5, 6, 7, 17, 21, 25, 29, 17, 21, 25, 29}));
228         v_dstu = vec_perm(v_dstu, v_src1_2,((vector unsigned char)
229                                             {0, 1, 2, 3, 4, 5, 6, 7, 19, 23, 27, 31, 17, 21, 25, 29}));
230
231         v_dstv = vec_perm(v_dstv, v_src1_3,((vector unsigned char)
232                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 21, 25, 29}));
233         v_dstu = vec_perm(v_dstu, v_src1_3,((vector unsigned char)
234                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 19, 23, 27, 31}));
235
236         vec_vsx_st((vector unsigned char)v_dstu, 0, (unsigned char *)dstu_addr);
237         vec_vsx_st((vector unsigned char)v_dstv, 0, (unsigned char *)dstv_addr);
238
239         src1_addr += 64;
240         dstu_addr += 16;
241         dstv_addr += 16;
242     }
243
244     for (i=width_adj; i< width_adj + frag_len; i++) {
245         dstV[i] = src1[4 * i + 1];
246         dstU[i] = src1[4 * i + 3];
247     }
248     av_assert1(src1 == src2);
249 }
250
251 static void uyvyToY_c_vsx(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
252                           uint32_t *unused)
253 {
254     int i, width_adj, frag_len;
255
256     uintptr_t src_addr = (uintptr_t)src;
257     uintptr_t dst_addr = (uintptr_t)dst;
258
259     // compute integral number of vector-length items and length of final fragment
260     width_adj = width >> 4;
261     width_adj = width_adj << 4;
262     frag_len = width - width_adj;
263
264     for ( i = 0; i < width_adj; i += 16) {
265         vector unsigned char v_rd0 = vec_vsx_ld(0, (unsigned char *)src_addr);
266         vector unsigned char v_rd1 = vec_vsx_ld(0, (unsigned char *)(src_addr + 16));
267
268         vector unsigned char v_dst = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
269                                                              {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31}));
270         vec_vsx_st((vector unsigned char)v_dst, 0, (unsigned char *)dst_addr);
271
272         src_addr += 32;
273         dst_addr += 16;
274     }
275
276     for (i=width_adj; i< width_adj + frag_len; i++) {
277         dst[i] = src[2 * i + 1];
278     }
279 }
280
281 static void uyvyToUV_c_vsx(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
282                            const uint8_t *src2, int width, uint32_t *unused)
283 {
284     int i, width_adj, frag_len;
285
286     uintptr_t src1_addr = (uintptr_t)src1;
287     uintptr_t dstu_addr = (uintptr_t)dstU;
288     uintptr_t dstv_addr = (uintptr_t)dstV;
289
290     // compute integral number of vector-length items and length of final fragment
291     width_adj = width >> 4;
292     width_adj = width_adj << 4;
293     frag_len = width - width_adj;
294
295     for ( i = 0; i < width_adj; i += 16) {
296         vector unsigned char v_src1_0 = vec_vsx_ld(0, (unsigned char *)src1_addr);
297         vector unsigned char v_src1_1 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 16));
298         vector unsigned char v_src1_2 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 32));
299         vector unsigned char v_src1_3 = vec_vsx_ld(0, (unsigned char *)(src1_addr + 48));
300
301         vector unsigned char v_dstu = vec_perm(v_src1_0, v_src1_1,
302                                               ((vector unsigned char)
303                                                {0, 4, 8, 12, 16, 20, 24, 28, 1, 5, 9, 13, 17, 21, 25, 29}));
304         vector unsigned char v_dstv = vec_perm(v_src1_0, v_src1_1,
305                                               ((vector unsigned char)
306                                                {2, 6, 10, 14, 18, 22, 26, 30, 1, 5, 9, 13, 17, 21, 25, 29}));
307
308         v_dstu = vec_perm(v_dstu, v_src1_2,((vector unsigned char)
309                                             {0, 1, 2, 3, 4, 5, 6, 7, 16, 20, 24, 28, 17, 21, 25, 29}));
310         v_dstv = vec_perm(v_dstv, v_src1_2,((vector unsigned char)
311                                             {0, 1, 2, 3, 4, 5, 6, 7, 18, 22, 26, 30, 17, 21, 25, 29}));
312
313         v_dstu = vec_perm(v_dstu, v_src1_3,((vector unsigned char)
314                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 20, 24, 28}));
315         v_dstv = vec_perm(v_dstv, v_src1_3,((vector unsigned char)
316                                           {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 18, 22, 26, 30}));
317
318         vec_vsx_st((vector unsigned char)v_dstu, 0, (unsigned char *)dstu_addr);
319         vec_vsx_st((vector unsigned char)v_dstv, 0, (unsigned char *)dstv_addr);
320
321         src1_addr += 64;
322         dstu_addr += 16;
323         dstv_addr += 16;
324     }
325
326     for (i=width_adj; i< width_adj + frag_len; i++) {
327         dstU[i] = src1[4 * i + 0];
328         dstV[i] = src1[4 * i + 2];
329     }
330     av_assert1(src1 == src2);
331 }
332
333 static av_always_inline void nvXXtoUV_c_vsx(uint8_t *dst1, uint8_t *dst2, const uint8_t *src, int width)
334 {
335     int i, width_adj, frag_len;
336
337     uintptr_t src_addr  = (uintptr_t)src;
338     uintptr_t dst1_addr = (uintptr_t)dst1;
339     uintptr_t dst2_addr = (uintptr_t)dst2;
340
341     // compute integral number of vector-length items and length of final fragment
342     width_adj = width >> 4;
343     width_adj = width_adj << 4;
344     frag_len = width - width_adj;
345
346     for ( i = 0; i < width_adj; i += 16) {
347         vector unsigned char v_rd0 = vec_vsx_ld(0, (unsigned char *)src_addr);
348         vector unsigned char v_rd1 = vec_vsx_ld(0, (unsigned char *)(src_addr + 16));
349
350         vector unsigned char v_dst1 = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
351                                                               {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}));
352         vector unsigned char v_dst2 = vec_perm(v_rd0, v_rd1, ((vector unsigned char)
353                                                               {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31}));
354
355         vec_vsx_st((vector unsigned char)v_dst1, 0, (unsigned char *)dst1_addr);
356         vec_vsx_st((vector unsigned char)v_dst2, 0, (unsigned char *)dst2_addr);
357
358         src_addr    += 32;
359         dst1_addr   += 16;
360         dst2_addr   += 16;
361     }
362
363     for (i=width_adj; i< width_adj + frag_len; i++) {
364         dst1[i] = src[2 * i + 0];
365         dst2[i] = src[2 * i + 1];
366     }
367 }
368
369 static void nv12ToUV_c_vsx(uint8_t *dstU, uint8_t *dstV,
370                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
371                            int width, uint32_t *unused)
372 {
373     nvXXtoUV_c_vsx(dstU, dstV, src1, width);
374 }
375
376 static void nv21ToUV_c_vsx(uint8_t *dstU, uint8_t *dstV,
377                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
378                            int width, uint32_t *unused)
379 {
380     nvXXtoUV_c_vsx(dstV, dstU, src1, width);
381 }
382
383 #endif /* HAVE_VSX */
384
385 av_cold void ff_sws_init_input_funcs_vsx(SwsContext *c)
386 {
387 #if HAVE_VSX
388
389     enum AVPixelFormat srcFormat = c->srcFormat;
390
391     switch (srcFormat) {
392     case AV_PIX_FMT_YUYV422:
393         c->chrToYV12 = yuy2ToUV_c_vsx;
394         break;
395     case AV_PIX_FMT_YVYU422:
396         c->chrToYV12 = yvy2ToUV_c_vsx;
397         break;
398     case AV_PIX_FMT_UYVY422:
399         c->chrToYV12 = uyvyToUV_c_vsx;
400         break;
401     case AV_PIX_FMT_NV12:
402         c->chrToYV12 = nv12ToUV_c_vsx;
403         break;
404     case AV_PIX_FMT_NV21:
405         c->chrToYV12 = nv21ToUV_c_vsx;
406         break;
407     }
408
409     switch (srcFormat) {
410     case AV_PIX_FMT_YUYV422:
411     case AV_PIX_FMT_YVYU422:
412     case AV_PIX_FMT_YA8:
413         c->lumToYV12 = yuy2ToY_c_vsx;
414         break;
415     case AV_PIX_FMT_UYVY422:
416         c->lumToYV12 = uyvyToY_c_vsx;
417         break;
418     }
419
420     if (c->needAlpha) {
421         switch (srcFormat) {
422         case AV_PIX_FMT_BGRA:
423         case AV_PIX_FMT_RGBA:
424             c->alpToYV12 = rgbaToA_c_vsx;
425             break;
426         case AV_PIX_FMT_ABGR:
427         case AV_PIX_FMT_ARGB:
428             c->alpToYV12 = abgrToA_c_vsx;
429             break;
430         case AV_PIX_FMT_YA8:
431             c->alpToYV12 = uyvyToY_c_vsx;
432             break;
433         }
434     }
435
436 #endif /* HAVE_VSX */
437 }