| /* |
| * Copyright (c) 2002 Brian Foley |
| * Copyright (c) 2002 Dieter Shirley |
| * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org> |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include "config.h" |
| |
| #include "libavutil/attributes.h" |
| #include "libavutil/cpu.h" |
| #include "libavutil/ppc/cpu.h" |
| #include "libavutil/ppc/util_altivec.h" |
| |
| #include "libavcodec/avcodec.h" |
| #include "libavcodec/pixblockdsp.h" |
| |
| #if HAVE_ALTIVEC |
| |
| #if HAVE_VSX |
| static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels, |
| ptrdiff_t stride) |
| { |
| int i; |
| vector unsigned char perm = |
| (vector unsigned char) {0x00,0x10, 0x01,0x11,0x02,0x12,0x03,0x13,\ |
| 0x04,0x14,0x05,0x15,0x06,0x16,0x07,0x17}; |
| const vector unsigned char zero = |
| (const vector unsigned char) vec_splat_u8(0); |
| |
| for (i = 0; i < 8; i++) { |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| vector unsigned char bytes = vec_vsx_ld(0, pixels); |
| |
| // Convert the bytes into shorts. |
| //vector signed short shorts = (vector signed short) vec_perm(zero, bytes, perm); |
| vector signed short shorts = (vector signed short) vec_perm(bytes, zero, perm); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_vsx_st(shorts, i * 16, (vector signed short *) block); |
| |
| pixels += stride; |
| } |
| } |
| #else |
| static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels, |
| ptrdiff_t stride) |
| { |
| int i; |
| const vec_u8 zero = (const vec_u8)vec_splat_u8(0); |
| |
| for (i = 0; i < 8; i++) { |
| vec_u8 perm = vec_lvsl(0, pixels); |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| vec_u8 pixl = vec_ld(0, pixels); |
| vec_u8 pixr = vec_ld(7, pixels); |
| vec_u8 bytes = vec_perm(pixl, pixr, perm); |
| |
| // Convert the bytes into shorts. |
| vec_s16 shorts = (vec_s16)vec_mergeh(zero, bytes); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_st(shorts, i * 16, (vec_s16 *)block); |
| |
| pixels += stride; |
| } |
| } |
| |
| #endif /* HAVE_VSX */ |
| |
| #if HAVE_VSX |
| static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1, |
| const uint8_t *s2, ptrdiff_t stride) |
| { |
| int i; |
| const vector unsigned char zero = |
| (const vector unsigned char) vec_splat_u8(0); |
| vector signed short shorts1, shorts2; |
| |
| for (i = 0; i < 4; i++) { |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| vector unsigned char bytes = vec_vsx_ld(0, s1); |
| |
| // Convert the bytes into shorts. |
| shorts1 = (vector signed short) vec_mergeh(bytes, zero); |
| |
| // Do the same for the second block of pixels. |
| bytes =vec_vsx_ld(0, s2); |
| |
| // Convert the bytes into shorts. |
| shorts2 = (vector signed short) vec_mergeh(bytes, zero); |
| |
| // Do the subtraction. |
| shorts1 = vec_sub(shorts1, shorts2); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_vsx_st(shorts1, 0, (vector signed short *) block); |
| |
| s1 += stride; |
| s2 += stride; |
| block += 8; |
| |
| /* The code below is a copy of the code above... |
| * This is a manual unroll. */ |
| |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| bytes = vec_vsx_ld(0, s1); |
| |
| // Convert the bytes into shorts. |
| shorts1 = (vector signed short) vec_mergeh(bytes, zero); |
| |
| // Do the same for the second block of pixels. |
| bytes = vec_vsx_ld(0, s2); |
| |
| // Convert the bytes into shorts. |
| shorts2 = (vector signed short) vec_mergeh(bytes, zero); |
| |
| // Do the subtraction. |
| shorts1 = vec_sub(shorts1, shorts2); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_vsx_st(shorts1, 0, (vector signed short *) block); |
| |
| s1 += stride; |
| s2 += stride; |
| block += 8; |
| } |
| } |
| #else |
| static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1, |
| const uint8_t *s2, ptrdiff_t stride) |
| { |
| int i; |
| vec_u8 perm; |
| const vec_u8 zero = (const vec_u8)vec_splat_u8(0); |
| vec_s16 shorts1, shorts2; |
| |
| for (i = 0; i < 4; i++) { |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| perm = vec_lvsl(0, s1); |
| vec_u8 pixl = vec_ld(0, s1); |
| vec_u8 pixr = vec_ld(15, s1); |
| vec_u8 bytes = vec_perm(pixl, pixr, perm); |
| |
| // Convert the bytes into shorts. |
| shorts1 = (vec_s16)vec_mergeh(zero, bytes); |
| |
| // Do the same for the second block of pixels. |
| perm = vec_lvsl(0, s2); |
| pixl = vec_ld(0, s2); |
| pixr = vec_ld(15, s2); |
| bytes = vec_perm(pixl, pixr, perm); |
| |
| // Convert the bytes into shorts. |
| shorts2 = (vec_s16)vec_mergeh(zero, bytes); |
| |
| // Do the subtraction. |
| shorts1 = vec_sub(shorts1, shorts2); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_st(shorts1, 0, (vec_s16 *)block); |
| |
| s1 += stride; |
| s2 += stride; |
| block += 8; |
| |
| /* The code below is a copy of the code above... |
| * This is a manual unroll. */ |
| |
| /* Read potentially unaligned pixels. |
| * We're reading 16 pixels, and actually only want 8, |
| * but we simply ignore the extras. */ |
| perm = vec_lvsl(0, s1); |
| pixl = vec_ld(0, s1); |
| pixr = vec_ld(15, s1); |
| bytes = vec_perm(pixl, pixr, perm); |
| |
| // Convert the bytes into shorts. |
| shorts1 = (vec_s16)vec_mergeh(zero, bytes); |
| |
| // Do the same for the second block of pixels. |
| perm = vec_lvsl(0, s2); |
| pixl = vec_ld(0, s2); |
| pixr = vec_ld(15, s2); |
| bytes = vec_perm(pixl, pixr, perm); |
| |
| // Convert the bytes into shorts. |
| shorts2 = (vec_s16)vec_mergeh(zero, bytes); |
| |
| // Do the subtraction. |
| shorts1 = vec_sub(shorts1, shorts2); |
| |
| // Save the data to the block, we assume the block is 16-byte aligned. |
| vec_st(shorts1, 0, (vec_s16 *)block); |
| |
| s1 += stride; |
| s2 += stride; |
| block += 8; |
| } |
| } |
| |
| #endif /* HAVE_VSX */ |
| |
| #endif /* HAVE_ALTIVEC */ |
| |
| #if HAVE_VSX |
| static void get_pixels_vsx(int16_t *restrict block, const uint8_t *pixels, |
| ptrdiff_t stride) |
| { |
| int i; |
| for (i = 0; i < 8; i++) { |
| vec_s16 shorts = vsx_ld_u8_s16(0, pixels); |
| |
| vec_vsx_st(shorts, i * 16, block); |
| |
| pixels += stride; |
| } |
| } |
| |
| static void diff_pixels_vsx(int16_t *restrict block, const uint8_t *s1, |
| const uint8_t *s2, ptrdiff_t stride) |
| { |
| int i; |
| vec_s16 shorts1, shorts2; |
| for (i = 0; i < 8; i++) { |
| shorts1 = vsx_ld_u8_s16(0, s1); |
| shorts2 = vsx_ld_u8_s16(0, s2); |
| |
| shorts1 = vec_sub(shorts1, shorts2); |
| |
| vec_vsx_st(shorts1, 0, block); |
| |
| s1 += stride; |
| s2 += stride; |
| block += 8; |
| } |
| } |
| #endif /* HAVE_VSX */ |
| |
| av_cold void ff_pixblockdsp_init_ppc(PixblockDSPContext *c, |
| AVCodecContext *avctx, |
| unsigned high_bit_depth) |
| { |
| #if HAVE_ALTIVEC |
| if (!PPC_ALTIVEC(av_get_cpu_flags())) |
| return; |
| |
| c->diff_pixels = diff_pixels_altivec; |
| |
| if (!high_bit_depth) { |
| c->get_pixels = get_pixels_altivec; |
| } |
| #endif /* HAVE_ALTIVEC */ |
| |
| #if HAVE_VSX |
| if (!PPC_VSX(av_get_cpu_flags())) |
| return; |
| |
| c->diff_pixels = diff_pixels_vsx; |
| |
| if (!high_bit_depth) |
| c->get_pixels = get_pixels_vsx; |
| #endif /* HAVE_VSX */ |
| } |