h264chroma: Change type of stride parameters to ptrdiff_t
[ffmpeg.git] / libavcodec / ppc / h264chroma_template.c
1 /*
2  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "libavutil/mem.h"
22
23 /* this code assume that stride % 16 == 0 */
24
25 #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \
26         vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc2uc);\
27         vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc3uc);\
28 \
29         psum = vec_mladd(vA, vsrc0ssH, BIAS1);\
30         psum = vec_mladd(vB, vsrc1ssH, psum);\
31         psum = vec_mladd(vC, vsrc2ssH, psum);\
32         psum = vec_mladd(vD, vsrc3ssH, psum);\
33         psum = BIAS2(psum);\
34         psum = vec_sr(psum, v6us);\
35 \
36         vdst = vec_ld(0, dst);\
37         ppsum = (vec_u8)vec_pack(psum, psum);\
38         vfdst = vec_perm(vdst, ppsum, fperm);\
39 \
40         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
41 \
42         vec_st(fsum, 0, dst);\
43 \
44         vsrc0ssH = vsrc2ssH;\
45         vsrc1ssH = vsrc3ssH;\
46 \
47         dst += stride;\
48         src += stride;
49
50 #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \
51 \
52         vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);\
53         vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);\
54 \
55         psum = vec_mladd(vA, vsrc0ssH, v32ss);\
56         psum = vec_mladd(vE, vsrc1ssH, psum);\
57         psum = vec_sr(psum, v6us);\
58 \
59         vdst = vec_ld(0, dst);\
60         ppsum = (vec_u8)vec_pack(psum, psum);\
61         vfdst = vec_perm(vdst, ppsum, fperm);\
62 \
63         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
64 \
65         vec_st(fsum, 0, dst);\
66 \
67         dst += stride;\
68         src += stride;
69
70 #define noop(a) a
71 #define add28(a) vec_add(v28ss, a)
72
73 #ifdef PREFIX_h264_chroma_mc8_altivec
74 static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
75                                            ptrdiff_t stride, int h,
76                                            int x, int y)
77 {
78     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
79                         {((8 - x) * (8 - y)),
80                          ((    x) * (8 - y)),
81                          ((8 - x) * (    y)),
82                          ((    x) * (    y))};
83     register int i;
84     vec_u8 fperm;
85     const vec_s32 vABCD = vec_ld(0, ABCD);
86     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
87     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
88     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
89     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
90     LOAD_ZERO;
91     const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));
92     const vec_u16 v6us = vec_splat_u16(6);
93     register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
94     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
95
96     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
97     vec_u8 vsrc0uc, vsrc1uc;
98     vec_s16 vsrc0ssH, vsrc1ssH;
99     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
100     vec_s16 vsrc2ssH, vsrc3ssH, psum;
101     vec_u8 vdst, ppsum, vfdst, fsum;
102
103     if (((unsigned long)dst) % 16 == 0) {
104         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
105                          0x14, 0x15, 0x16, 0x17,
106                          0x08, 0x09, 0x0A, 0x0B,
107                          0x0C, 0x0D, 0x0E, 0x0F};
108     } else {
109         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
110                          0x04, 0x05, 0x06, 0x07,
111                          0x18, 0x19, 0x1A, 0x1B,
112                          0x1C, 0x1D, 0x1E, 0x1F};
113     }
114
115     vsrcAuc = vec_ld(0, src);
116
117     if (loadSecond)
118         vsrcBuc = vec_ld(16, src);
119     vsrcperm0 = vec_lvsl(0, src);
120     vsrcperm1 = vec_lvsl(1, src);
121
122     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
123     if (reallyBadAlign)
124         vsrc1uc = vsrcBuc;
125     else
126         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
127
128     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);
129     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);
130
131     if (ABCD[3]) {
132         if (!loadSecond) {// -> !reallyBadAlign
133             for (i = 0 ; i < h ; i++) {
134                 vsrcCuc = vec_ld(stride + 0, src);
135                 vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
136                 vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
137
138                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
139             }
140         } else {
141             vec_u8 vsrcDuc;
142             for (i = 0 ; i < h ; i++) {
143                 vsrcCuc = vec_ld(stride + 0, src);
144                 vsrcDuc = vec_ld(stride + 16, src);
145                 vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
146                 if (reallyBadAlign)
147                     vsrc3uc = vsrcDuc;
148                 else
149                     vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
150
151                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
152             }
153         }
154     } else {
155         const vec_s16 vE = vec_add(vB, vC);
156         if (ABCD[2]) { // x == 0 B == 0
157             if (!loadSecond) {// -> !reallyBadAlign
158                 for (i = 0 ; i < h ; i++) {
159                     vsrcCuc = vec_ld(stride + 0, src);
160                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
161                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
162
163                     vsrc0uc = vsrc1uc;
164                 }
165             } else {
166                 vec_u8 vsrcDuc;
167                 for (i = 0 ; i < h ; i++) {
168                     vsrcCuc = vec_ld(stride + 0, src);
169                     vsrcDuc = vec_ld(stride + 15, src);
170                     vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
171                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
172
173                     vsrc0uc = vsrc1uc;
174                 }
175             }
176         } else { // y == 0 C == 0
177             if (!loadSecond) {// -> !reallyBadAlign
178                 for (i = 0 ; i < h ; i++) {
179                     vsrcCuc = vec_ld(0, src);
180                     vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
181                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
182
183                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
184                 }
185             } else {
186                 vec_u8 vsrcDuc;
187                 for (i = 0 ; i < h ; i++) {
188                     vsrcCuc = vec_ld(0, src);
189                     vsrcDuc = vec_ld(15, src);
190                     vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
191                     if (reallyBadAlign)
192                         vsrc1uc = vsrcDuc;
193                     else
194                         vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
195
196                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
197                 }
198             }
199         }
200     }
201 }
202 #endif
203
204 /* this code assume that stride % 16 == 0 */
205 #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
206 static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t *dst, uint8_t *src,
207                                                  ptrdiff_t stride, int h,
208                                                  int x, int y)
209 {
210    DECLARE_ALIGNED(16, signed int, ABCD)[4] =
211                         {((8 - x) * (8 - y)),
212                          ((    x) * (8 - y)),
213                          ((8 - x) * (    y)),
214                          ((    x) * (    y))};
215     register int i;
216     vec_u8 fperm;
217     const vec_s32 vABCD = vec_ld(0, ABCD);
218     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
219     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
220     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
221     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
222     LOAD_ZERO;
223     const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));
224     const vec_u16 v6us  = vec_splat_u16(6);
225     register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
226     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
227
228     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
229     vec_u8 vsrc0uc, vsrc1uc;
230     vec_s16 vsrc0ssH, vsrc1ssH;
231     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
232     vec_s16 vsrc2ssH, vsrc3ssH, psum;
233     vec_u8 vdst, ppsum, vfdst, fsum;
234
235     if (((unsigned long)dst) % 16 == 0) {
236         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
237                          0x14, 0x15, 0x16, 0x17,
238                          0x08, 0x09, 0x0A, 0x0B,
239                          0x0C, 0x0D, 0x0E, 0x0F};
240     } else {
241         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
242                          0x04, 0x05, 0x06, 0x07,
243                          0x18, 0x19, 0x1A, 0x1B,
244                          0x1C, 0x1D, 0x1E, 0x1F};
245     }
246
247     vsrcAuc = vec_ld(0, src);
248
249     if (loadSecond)
250         vsrcBuc = vec_ld(16, src);
251     vsrcperm0 = vec_lvsl(0, src);
252     vsrcperm1 = vec_lvsl(1, src);
253
254     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
255     if (reallyBadAlign)
256         vsrc1uc = vsrcBuc;
257     else
258         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
259
260     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);
261     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);
262
263     if (!loadSecond) {// -> !reallyBadAlign
264         for (i = 0 ; i < h ; i++) {
265
266
267             vsrcCuc = vec_ld(stride + 0, src);
268
269             vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
270             vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
271
272             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
273         }
274     } else {
275         vec_u8 vsrcDuc;
276         for (i = 0 ; i < h ; i++) {
277             vsrcCuc = vec_ld(stride + 0, src);
278             vsrcDuc = vec_ld(stride + 16, src);
279
280             vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
281             if (reallyBadAlign)
282                 vsrc3uc = vsrcDuc;
283             else
284                 vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
285
286             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
287         }
288     }
289 }
290 #endif
291
292 #undef noop
293 #undef add28
294 #undef CHROMA_MC8_ALTIVEC_CORE