FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
h264chroma_template.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
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 "libavutil/mem.h"
22 #include "libavutil/ppc/types_altivec.h"
23 #include "libavutil/ppc/util_altivec.h"
24 
25 /* this code assume that stride % 16 == 0 */
26 
27 #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \
28  vsrc2ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc2uc);\
29  vsrc3ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc3uc);\
30 \
31  psum = vec_mladd(vA, vsrc0ssH, BIAS1);\
32  psum = vec_mladd(vB, vsrc1ssH, psum);\
33  psum = vec_mladd(vC, vsrc2ssH, psum);\
34  psum = vec_mladd(vD, vsrc3ssH, psum);\
35  psum = BIAS2(psum);\
36  psum = vec_sr(psum, v6us);\
37 \
38  vdst = vec_ld(0, dst);\
39  ppsum = (vec_u8)vec_pack(psum, psum);\
40  vfdst = vec_perm(vdst, ppsum, fperm);\
41 \
42  OP_U8_ALTIVEC(fsum, vfdst, vdst);\
43 \
44  vec_st(fsum, 0, dst);\
45 \
46  vsrc0ssH = vsrc2ssH;\
47  vsrc1ssH = vsrc3ssH;\
48 \
49  dst += stride;\
50  src += stride;
51 
52 #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \
53 \
54  vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc0uc);\
55  vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc1uc);\
56 \
57  psum = vec_mladd(vA, vsrc0ssH, v32ss);\
58  psum = vec_mladd(vE, vsrc1ssH, psum);\
59  psum = vec_sr(psum, v6us);\
60 \
61  vdst = vec_ld(0, dst);\
62  ppsum = (vec_u8)vec_pack(psum, psum);\
63  vfdst = vec_perm(vdst, ppsum, fperm);\
64 \
65  OP_U8_ALTIVEC(fsum, vfdst, vdst);\
66 \
67  vec_st(fsum, 0, dst);\
68 \
69  dst += stride;\
70  src += stride;
71 
72 #define noop(a) a
73 #define add28(a) vec_add(v28ss, a)
74 
75 #if HAVE_BIGENDIAN
76 #define GET_VSRC1(vs0, off, b, perm0, s){ \
77  vec_u8 vsrcCuc, vsrcDuc; \
78  vsrcCuc = vec_ld(off, s); \
79  if (loadSecond){ \
80  vsrcDuc = vec_ld(off + b, s); \
81  } else \
82  vsrcDuc = vsrcCuc; \
83  \
84  vs0 = vec_perm(vsrcCuc, vsrcDuc, perm0); \
85 }
86 #define GET_VSRC(vs0, vs1, off, b, perm0, perm1, s){ \
87  vec_u8 vsrcCuc, vsrcDuc; \
88  vsrcCuc = vec_ld(off, s); \
89  if (loadSecond){ \
90  vsrcDuc = vec_ld(off + b, s); \
91  } else \
92  vsrcDuc = vsrcCuc; \
93  \
94  vs0 = vec_perm(vsrcCuc, vsrcDuc, perm0); \
95  if (reallyBadAlign){ \
96  vs1 = vsrcDuc; \
97  } else \
98  vs1 = vec_perm(vsrcCuc, vsrcDuc, perm1); \
99  }
100 
101 #else
102 
103 #define GET_VSRC1(vs0, off, b, perm0, s){ \
104  vs0 = vec_vsx_ld(off, s); \
105  }
106 #define GET_VSRC(vs0, vs1, off, b, perm0, perm1, s){ \
107  vs0 = vec_vsx_ld(off, s); \
108  vs1 = vec_vsx_ld(off + 1, s); \
109  }
110 #endif /* HAVE_BIGENDIAN */
111 
112 #ifdef PREFIX_h264_chroma_mc8_altivec
113 static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
114  int stride, int h, int x, int y) {
115  DECLARE_ALIGNED(16, signed int, ABCD)[4] =
116  {((8 - x) * (8 - y)),
117  (( x) * (8 - y)),
118  ((8 - x) * ( y)),
119  (( x) * ( y))};
120  register int i;
121  vec_u8 fperm;
122  LOAD_ZERO;
123  const vec_s32 vABCD = vec_ld(0, ABCD);
124  const vec_s16 vA = VEC_SPLAT16(vABCD, 1);
125  const vec_s16 vB = VEC_SPLAT16(vABCD, 3);
126  const vec_s16 vC = VEC_SPLAT16(vABCD, 5);
127  const vec_s16 vD = VEC_SPLAT16(vABCD, 7);
128  const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));
129  const vec_u16 v6us = vec_splat_u16(6);
130 
131  vec_u8 vsrcperm0, vsrcperm1;
132  vec_u8 vsrc0uc, vsrc1uc;
133  vec_s16 vsrc0ssH, vsrc1ssH;
134  vec_u8 vsrc2uc, vsrc3uc;
135  vec_s16 vsrc2ssH, vsrc3ssH, psum;
136  vec_u8 vdst, ppsum, vfdst, fsum;
137 #if HAVE_BIGENDIAN
138  register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
139  register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
140  vsrcperm0 = vec_lvsl(0, src);
141  vsrcperm1 = vec_lvsl(1, src);
142 #endif
143 
144  if (((unsigned long)dst) % 16 == 0) {
145  fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
146  0x14, 0x15, 0x16, 0x17,
147  0x08, 0x09, 0x0A, 0x0B,
148  0x0C, 0x0D, 0x0E, 0x0F};
149  } else {
150  fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
151  0x04, 0x05, 0x06, 0x07,
152  0x18, 0x19, 0x1A, 0x1B,
153  0x1C, 0x1D, 0x1E, 0x1F};
154  }
155 
156  GET_VSRC(vsrc0uc, vsrc1uc, 0, 16, vsrcperm0, vsrcperm1, src);
157 
158  vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc0uc);
159  vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc1uc);
160 
161  if (ABCD[3]) {
162  for (i = 0 ; i < h ; i++) {
163  GET_VSRC(vsrc2uc, vsrc3uc, stride, 16, vsrcperm0, vsrcperm1, src);
164  CHROMA_MC8_ALTIVEC_CORE(v32ss, noop);
165  }
166  } else {
167  const vec_s16 vE = vec_add(vB, vC);
168  if (ABCD[2]) { // x == 0 B == 0
169  for (i = 0 ; i < h ; i++) {
170  GET_VSRC1(vsrc1uc, stride, 15, vsrcperm0, src);
171  CHROMA_MC8_ALTIVEC_CORE_SIMPLE;
172  vsrc0uc = vsrc1uc;
173  }
174  } else { // y == 0 C == 0
175  for (i = 0 ; i < h ; i++) {
176  GET_VSRC(vsrc0uc, vsrc1uc, 0, 15, vsrcperm0, vsrcperm1, src);
177  CHROMA_MC8_ALTIVEC_CORE_SIMPLE;
178  }
179  }
180  }
181 }
182 #endif
183 
184 /* this code assume that stride % 16 == 0 */
185 #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
186 static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {
187  DECLARE_ALIGNED(16, signed int, ABCD)[4] =
188  {((8 - x) * (8 - y)),
189  (( x) * (8 - y)),
190  ((8 - x) * ( y)),
191  (( x) * ( y))};
192  register int i;
193  vec_u8 fperm;
194  LOAD_ZERO;
195  const vec_s32 vABCD = vec_ld(0, ABCD);
196  const vec_s16 vA = VEC_SPLAT16(vABCD, 1);
197  const vec_s16 vB = VEC_SPLAT16(vABCD, 3);
198  const vec_s16 vC = VEC_SPLAT16(vABCD, 5);
199  const vec_s16 vD = VEC_SPLAT16(vABCD, 7);
200  const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));
201  const vec_u16 v6us = vec_splat_u16(6);
202 
203  vec_u8 vsrcperm0, vsrcperm1;
204  vec_u8 vsrc0uc, vsrc1uc;
205  vec_s16 vsrc0ssH, vsrc1ssH;
206  vec_u8 vsrc2uc, vsrc3uc;
207  vec_s16 vsrc2ssH, vsrc3ssH, psum;
208  vec_u8 vdst, ppsum, vfdst, fsum;
209 #if HAVE_BIGENDIAN
210  register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
211  register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
212  vsrcperm0 = vec_lvsl(0, src);
213  vsrcperm1 = vec_lvsl(1, src);
214 #endif
215 
216  if (((unsigned long)dst) % 16 == 0) {
217  fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
218  0x14, 0x15, 0x16, 0x17,
219  0x08, 0x09, 0x0A, 0x0B,
220  0x0C, 0x0D, 0x0E, 0x0F};
221  } else {
222  fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
223  0x04, 0x05, 0x06, 0x07,
224  0x18, 0x19, 0x1A, 0x1B,
225  0x1C, 0x1D, 0x1E, 0x1F};
226  }
227 
228  GET_VSRC(vsrc0uc, vsrc1uc, 0, 16, vsrcperm0, vsrcperm1, src);
229 
230  vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v, (vec_u8)vsrc0uc);
231  vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v, (vec_u8)vsrc1uc);
232 
233  for (i = 0 ; i < h ; i++) {
234  GET_VSRC(vsrc2uc, vsrc3uc, stride, 16, vsrcperm0, vsrcperm1, src);
235  CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28);
236  }
237 }
238 #endif
239 
240 #undef noop
241 #undef add28
242 #undef CHROMA_MC8_ALTIVEC_CORE
h
h
Definition: vp9dsp_template.c:2093
mem.h
Memory handling functions.
vec_s32
#define vec_s32
Definition: types_altivec.h:32
uint8_t
uint8_t
Definition: audio_convert.c:194
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
vec_s16
#define vec_s16
Definition: types_altivec.h:30
GET_VSRC1
#define GET_VSRC1(vs0, off, b, perm0, s)
Definition: h264chroma_template.c:103
vec_u16
#define vec_u16
Definition: types_altivec.h:29
LOAD_ZERO
#define LOAD_ZERO
Definition: types_altivec.h:38
noop
#define noop(a)
Definition: h264chroma_template.c:72
src
#define src
Definition: vp9dsp.c:530
vec_u8
#define vec_u8
Definition: types_altivec.h:27
types_altivec.h
util_altivec.h
Contains misc utility macros and inline functions.
GET_VSRC
#define GET_VSRC(vs0, vs1, off, b, perm0, perm1, s)
Definition: h264chroma_template.c:106
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
CHROMA_MC8_ALTIVEC_CORE_SIMPLE
#define CHROMA_MC8_ALTIVEC_CORE_SIMPLE
Definition: h264chroma_template.c:52
CHROMA_MC8_ALTIVEC_CORE
#define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2)
Definition: h264chroma_template.c:27
add28
#define add28(a)
Definition: h264chroma_template.c:73
zero_u8v
#define zero_u8v
Definition: types_altivec.h:40
Generated on Thu Oct 27 2016 19:33:24 for FFmpeg by   doxygen 1.8.6