2 * Copyright (c) 2002 Brian Foley
3 * Copyright (c) 2002 Dieter Shirley
4 * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "libavutil/attributes.h"
26 #include "libavutil/cpu.h"
27 #include "libavutil/ppc/cpu.h"
28 #include "libavutil/ppc/util_altivec.h"
30 #include "libavcodec/avcodec.h"
31 #include "libavcodec/pixblockdsp.h"
36 static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
40 vector unsigned char perm =
41 (vector unsigned char) {0x00,0x10, 0x01,0x11,0x02,0x12,0x03,0x13,\
42 0x04,0x14,0x05,0x15,0x06,0x16,0x07,0x17};
43 const vector unsigned char zero =
44 (const vector unsigned char) vec_splat_u8(0);
46 for (i = 0; i < 8; i++) {
47 /* Read potentially unaligned pixels.
48 * We're reading 16 pixels, and actually only want 8,
49 * but we simply ignore the extras. */
50 vector unsigned char bytes = vec_vsx_ld(0, pixels);
52 // Convert the bytes into shorts.
53 //vector signed short shorts = (vector signed short) vec_perm(zero, bytes, perm);
54 vector signed short shorts = (vector signed short) vec_perm(bytes, zero, perm);
56 // Save the data to the block, we assume the block is 16-byte aligned.
57 vec_vsx_st(shorts, i * 16, (vector signed short *) block);
63 static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
67 const vec_u8 zero = (const vec_u8)vec_splat_u8(0);
69 for (i = 0; i < 8; i++) {
70 vec_u8 perm = vec_lvsl(0, pixels);
71 /* Read potentially unaligned pixels.
72 * We're reading 16 pixels, and actually only want 8,
73 * but we simply ignore the extras. */
74 vec_u8 pixl = vec_ld(0, pixels);
75 vec_u8 pixr = vec_ld(7, pixels);
76 vec_u8 bytes = vec_perm(pixl, pixr, perm);
78 // Convert the bytes into shorts.
79 vec_s16 shorts = (vec_s16)vec_mergeh(zero, bytes);
81 // Save the data to the block, we assume the block is 16-byte aligned.
82 vec_st(shorts, i * 16, (vec_s16 *)block);
91 static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
92 const uint8_t *s2, ptrdiff_t stride)
95 const vector unsigned char zero =
96 (const vector unsigned char) vec_splat_u8(0);
97 vector signed short shorts1, shorts2;
99 for (i = 0; i < 4; i++) {
100 /* Read potentially unaligned pixels.
101 * We're reading 16 pixels, and actually only want 8,
102 * but we simply ignore the extras. */
103 vector unsigned char bytes = vec_vsx_ld(0, s1);
105 // Convert the bytes into shorts.
106 shorts1 = (vector signed short) vec_mergeh(bytes, zero);
108 // Do the same for the second block of pixels.
109 bytes =vec_vsx_ld(0, s2);
111 // Convert the bytes into shorts.
112 shorts2 = (vector signed short) vec_mergeh(bytes, zero);
114 // Do the subtraction.
115 shorts1 = vec_sub(shorts1, shorts2);
117 // Save the data to the block, we assume the block is 16-byte aligned.
118 vec_vsx_st(shorts1, 0, (vector signed short *) block);
124 /* The code below is a copy of the code above...
125 * This is a manual unroll. */
127 /* Read potentially unaligned pixels.
128 * We're reading 16 pixels, and actually only want 8,
129 * but we simply ignore the extras. */
130 bytes = vec_vsx_ld(0, s1);
132 // Convert the bytes into shorts.
133 shorts1 = (vector signed short) vec_mergeh(bytes, zero);
135 // Do the same for the second block of pixels.
136 bytes = vec_vsx_ld(0, s2);
138 // Convert the bytes into shorts.
139 shorts2 = (vector signed short) vec_mergeh(bytes, zero);
141 // Do the subtraction.
142 shorts1 = vec_sub(shorts1, shorts2);
144 // Save the data to the block, we assume the block is 16-byte aligned.
145 vec_vsx_st(shorts1, 0, (vector signed short *) block);
153 static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
154 const uint8_t *s2, ptrdiff_t stride)
158 const vec_u8 zero = (const vec_u8)vec_splat_u8(0);
159 vec_s16 shorts1, shorts2;
161 for (i = 0; i < 4; i++) {
162 /* Read potentially unaligned pixels.
163 * We're reading 16 pixels, and actually only want 8,
164 * but we simply ignore the extras. */
165 perm = vec_lvsl(0, s1);
166 vec_u8 pixl = vec_ld(0, s1);
167 vec_u8 pixr = vec_ld(15, s1);
168 vec_u8 bytes = vec_perm(pixl, pixr, perm);
170 // Convert the bytes into shorts.
171 shorts1 = (vec_s16)vec_mergeh(zero, bytes);
173 // Do the same for the second block of pixels.
174 perm = vec_lvsl(0, s2);
175 pixl = vec_ld(0, s2);
176 pixr = vec_ld(15, s2);
177 bytes = vec_perm(pixl, pixr, perm);
179 // Convert the bytes into shorts.
180 shorts2 = (vec_s16)vec_mergeh(zero, bytes);
182 // Do the subtraction.
183 shorts1 = vec_sub(shorts1, shorts2);
185 // Save the data to the block, we assume the block is 16-byte aligned.
186 vec_st(shorts1, 0, (vec_s16 *)block);
192 /* The code below is a copy of the code above...
193 * This is a manual unroll. */
195 /* Read potentially unaligned pixels.
196 * We're reading 16 pixels, and actually only want 8,
197 * but we simply ignore the extras. */
198 perm = vec_lvsl(0, s1);
199 pixl = vec_ld(0, s1);
200 pixr = vec_ld(15, s1);
201 bytes = vec_perm(pixl, pixr, perm);
203 // Convert the bytes into shorts.
204 shorts1 = (vec_s16)vec_mergeh(zero, bytes);
206 // Do the same for the second block of pixels.
207 perm = vec_lvsl(0, s2);
208 pixl = vec_ld(0, s2);
209 pixr = vec_ld(15, s2);
210 bytes = vec_perm(pixl, pixr, perm);
212 // Convert the bytes into shorts.
213 shorts2 = (vec_s16)vec_mergeh(zero, bytes);
215 // Do the subtraction.
216 shorts1 = vec_sub(shorts1, shorts2);
218 // Save the data to the block, we assume the block is 16-byte aligned.
219 vec_st(shorts1, 0, (vec_s16 *)block);
227 #endif /* HAVE_VSX */
229 #endif /* HAVE_ALTIVEC */
232 static void get_pixels_vsx(int16_t *restrict block, const uint8_t *pixels,
236 for (i = 0; i < 8; i++) {
237 vec_s16 shorts = vsx_ld_u8_s16(0, pixels);
239 vec_vsx_st(shorts, i * 16, block);
245 static void diff_pixels_vsx(int16_t *restrict block, const uint8_t *s1,
246 const uint8_t *s2, ptrdiff_t stride)
249 vec_s16 shorts1, shorts2;
250 for (i = 0; i < 8; i++) {
251 shorts1 = vsx_ld_u8_s16(0, s1);
252 shorts2 = vsx_ld_u8_s16(0, s2);
254 shorts1 = vec_sub(shorts1, shorts2);
256 vec_vsx_st(shorts1, 0, block);
263 #endif /* HAVE_VSX */
265 av_cold void ff_pixblockdsp_init_ppc(PixblockDSPContext *c,
266 AVCodecContext *avctx,
267 unsigned high_bit_depth)
270 if (!PPC_ALTIVEC(av_get_cpu_flags()))
273 c->diff_pixels = diff_pixels_altivec;
275 if (!high_bit_depth) {
276 c->get_pixels = get_pixels_altivec;
278 #endif /* HAVE_ALTIVEC */
281 if (!PPC_VSX(av_get_cpu_flags()))
284 c->diff_pixels = diff_pixels_vsx;
287 c->get_pixels = get_pixels_vsx;
288 #endif /* HAVE_VSX */