Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4348 → Rev 4349

/contrib/sdk/sources/ffmpeg/libavutil/ppc/Makefile
0,0 → 1,4
OBJS += ppc/cpu.o \
ppc/float_dsp_init.o \
 
ALTIVEC-OBJS += ppc/float_dsp_altivec.o \
/contrib/sdk/sources/ffmpeg/libavutil/ppc/cpu.c
0,0 → 1,84
/*
* 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
*/
 
#ifdef __APPLE__
#include <sys/sysctl.h>
#elif defined(__OpenBSD__)
#include <sys/param.h>
#include <sys/sysctl.h>
#include <machine/cpu.h>
#elif defined(__AMIGAOS4__)
#include <exec/exec.h>
#include <interfaces/exec.h>
#include <proto/exec.h>
#endif /* __APPLE__ */
 
#include "libavutil/cpu.h"
#include "libavutil/cpu_internal.h"
#include "config.h"
 
/**
* This function MAY rely on signal() or fork() in order to make sure AltiVec
* is present.
*/
int ff_get_cpu_flags_ppc(void)
{
#if HAVE_ALTIVEC
#ifdef __AMIGAOS4__
ULONG result = 0;
extern struct ExecIFace *IExec;
 
IExec->GetCPUInfoTags(GCIT_VectorUnit, &result, TAG_DONE);
if (result == VECTORTYPE_ALTIVEC)
return AV_CPU_FLAG_ALTIVEC;
return 0;
#elif defined(__APPLE__) || defined(__OpenBSD__)
#ifdef __OpenBSD__
int sels[2] = {CTL_MACHDEP, CPU_ALTIVEC};
#else
int sels[2] = {CTL_HW, HW_VECTORUNIT};
#endif
int has_vu = 0;
size_t len = sizeof(has_vu);
int err;
 
err = sysctl(sels, 2, &has_vu, &len, NULL, 0);
 
if (err == 0)
return has_vu ? AV_CPU_FLAG_ALTIVEC : 0;
return 0;
#elif CONFIG_RUNTIME_CPUDETECT && defined(__linux__) && !ARCH_PPC64
int proc_ver;
// Support of mfspr PVR emulation added in Linux 2.6.17.
__asm__ volatile("mfspr %0, 287" : "=r" (proc_ver));
proc_ver >>= 16;
if (proc_ver & 0x8000 ||
proc_ver == 0x000c ||
proc_ver == 0x0039 || proc_ver == 0x003c ||
proc_ver == 0x0044 || proc_ver == 0x0045 ||
proc_ver == 0x0070)
return AV_CPU_FLAG_ALTIVEC;
return 0;
#else
// Since we were compiled for AltiVec, just assume we have it
// until someone comes up with a proper way (not involving signal hacks).
return AV_CPU_FLAG_ALTIVEC;
#endif /* __AMIGAOS4__ */
#endif /* HAVE_ALTIVEC */
return 0;
}
/contrib/sdk/sources/ffmpeg/libavutil/ppc/cpu.h
0,0 → 1,28
/*
* 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
*/
 
#ifndef AVUTIL_PPC_CPU_H
#define AVUTIL_PPC_CPU_H
 
#include "config.h"
#include "libavutil/cpu.h"
#include "libavutil/cpu_internal.h"
 
#define PPC_ALTIVEC(flags) CPUEXT(flags, ALTIVEC)
 
#endif /* AVUTIL_PPC_CPU_H */
/contrib/sdk/sources/ffmpeg/libavutil/ppc/float_dsp_altivec.c
0,0 → 1,124
/*
* Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.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 "util_altivec.h"
#include "float_dsp_altivec.h"
 
void ff_vector_fmul_altivec(float *dst, const float *src0, const float *src1,
int len)
{
int i;
vector float d0, d1, s, zero = (vector float)vec_splat_u32(0);
for (i = 0; i < len - 7; i += 8) {
d0 = vec_ld( 0, src0 + i);
s = vec_ld( 0, src1 + i);
d1 = vec_ld(16, src0 + i);
d0 = vec_madd(d0, s, zero);
d1 = vec_madd(d1, vec_ld(16, src1 + i), zero);
vec_st(d0, 0, dst + i);
vec_st(d1, 16, dst + i);
}
}
 
void ff_vector_fmul_window_altivec(float *dst, const float *src0,
const float *src1, const float *win, int len)
{
vector float zero, t0, t1, s0, s1, wi, wj;
const vector unsigned char reverse = vcprm(3, 2, 1, 0);
int i, j;
 
dst += len;
win += len;
src0 += len;
 
zero = (vector float)vec_splat_u32(0);
 
for (i = -len * 4, j = len * 4 - 16; i < 0; i += 16, j -= 16) {
s0 = vec_ld(i, src0);
s1 = vec_ld(j, src1);
wi = vec_ld(i, win);
wj = vec_ld(j, win);
 
s1 = vec_perm(s1, s1, reverse);
wj = vec_perm(wj, wj, reverse);
 
t0 = vec_madd(s0, wj, zero);
t0 = vec_nmsub(s1, wi, t0);
t1 = vec_madd(s0, wi, zero);
t1 = vec_madd(s1, wj, t1);
t1 = vec_perm(t1, t1, reverse);
 
vec_st(t0, i, dst);
vec_st(t1, j, dst);
}
}
 
void ff_vector_fmul_add_altivec(float *dst, const float *src0,
const float *src1, const float *src2,
int len)
{
int i;
vector float d, s0, s1, s2, t0, t1, edges;
vector unsigned char align = vec_lvsr(0,dst),
mask = vec_lvsl(0, dst);
 
for (i = 0; i < len - 3; i += 4) {
t0 = vec_ld(0, dst + i);
t1 = vec_ld(15, dst + i);
s0 = vec_ld(0, src0 + i);
s1 = vec_ld(0, src1 + i);
s2 = vec_ld(0, src2 + i);
edges = vec_perm(t1, t0, mask);
d = vec_madd(s0, s1, s2);
t1 = vec_perm(d, edges, align);
t0 = vec_perm(edges, d, align);
vec_st(t1, 15, dst + i);
vec_st(t0, 0, dst + i);
}
}
 
void ff_vector_fmul_reverse_altivec(float *dst, const float *src0,
const float *src1, int len)
{
int i;
vector float d, s0, s1, h0, l0,
s2, s3, zero = (vector float) vec_splat_u32(0);
 
src1 += len-4;
for(i = 0; i < len - 7; i += 8) {
s1 = vec_ld(0, src1 - i); // [a,b,c,d]
s0 = vec_ld(0, src0 + i);
l0 = vec_mergel(s1, s1); // [c,c,d,d]
s3 = vec_ld(-16, src1 - i);
h0 = vec_mergeh(s1, s1); // [a,a,b,b]
s2 = vec_ld(16, src0 + i);
s1 = vec_mergeh(vec_mergel(l0, h0), // [d,b,d,b]
vec_mergeh(l0, h0)); // [c,a,c,a]
// [d,c,b,a]
l0 = vec_mergel(s3, s3);
d = vec_madd(s0, s1, zero);
h0 = vec_mergeh(s3, s3);
vec_st(d, 0, dst + i);
s3 = vec_mergeh(vec_mergel(l0, h0),
vec_mergeh(l0, h0));
d = vec_madd(s2, s3, zero);
vec_st(d, 16, dst + i);
}
}
/contrib/sdk/sources/ffmpeg/libavutil/ppc/float_dsp_altivec.h
0,0 → 1,38
/*
* Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.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
*/
 
#ifndef AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H
#define AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H
 
void ff_vector_fmul_altivec(float *dst, const float *src0,
const float *src1, int len);
 
void ff_vector_fmul_window_altivec(float *dst, const float *src0,
const float *src1, const float *win,
int len);
 
void ff_vector_fmul_add_altivec(float *dst, const float *src0,
const float *src1, const float *src2,
int len);
 
void ff_vector_fmul_reverse_altivec(float *dst, const float *src0,
const float *src1, int len);
 
#endif /* AVUTIL_PPC_FLOAT_DSP_ALTIVEC_H */
/contrib/sdk/sources/ffmpeg/libavutil/ppc/float_dsp_init.c
0,0 → 1,40
/*
* Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.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/float_dsp.h"
#include "libavutil/ppc/cpu.h"
#include "float_dsp_altivec.h"
 
av_cold void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int bit_exact)
{
if (!PPC_ALTIVEC(av_get_cpu_flags()))
return;
 
fdsp->vector_fmul = ff_vector_fmul_altivec;
fdsp->vector_fmul_add = ff_vector_fmul_add_altivec;
fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_altivec;
 
if (!bit_exact) {
fdsp->vector_fmul_window = ff_vector_fmul_window_altivec;
}
}
/contrib/sdk/sources/ffmpeg/libavutil/ppc/intreadwrite.h
0,0 → 1,108
/*
* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
*
* 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
*/
 
#ifndef AVUTIL_PPC_INTREADWRITE_H
#define AVUTIL_PPC_INTREADWRITE_H
 
#include <stdint.h>
#include "config.h"
 
#if HAVE_XFORM_ASM
 
#define AV_RL16 AV_RL16
static av_always_inline uint16_t AV_RL16(const void *p)
{
uint16_t v;
__asm__ ("lhbrx %0, %y1" : "=r"(v) : "Z"(*(const uint16_t*)p));
return v;
}
 
#define AV_WL16 AV_WL16
static av_always_inline void AV_WL16(void *p, uint16_t v)
{
__asm__ ("sthbrx %1, %y0" : "=Z"(*(uint16_t*)p) : "r"(v));
}
 
#define AV_RL32 AV_RL32
static av_always_inline uint32_t AV_RL32(const void *p)
{
uint32_t v;
__asm__ ("lwbrx %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
return v;
}
 
#define AV_WL32 AV_WL32
static av_always_inline void AV_WL32(void *p, uint32_t v)
{
__asm__ ("stwbrx %1, %y0" : "=Z"(*(uint32_t*)p) : "r"(v));
}
 
#if HAVE_LDBRX
 
#define AV_RL64 AV_RL64
static av_always_inline uint64_t AV_RL64(const void *p)
{
uint64_t v;
__asm__ ("ldbrx %0, %y1" : "=r"(v) : "Z"(*(const uint64_t*)p));
return v;
}
 
#define AV_WL64 AV_WL64
static av_always_inline void AV_WL64(void *p, uint64_t v)
{
__asm__ ("stdbrx %1, %y0" : "=Z"(*(uint64_t*)p) : "r"(v));
}
 
#else
 
#define AV_RL64 AV_RL64
static av_always_inline uint64_t AV_RL64(const void *p)
{
union { uint64_t v; uint32_t hl[2]; } v;
__asm__ ("lwbrx %0, %y2 \n\t"
"lwbrx %1, %y3 \n\t"
: "=&r"(v.hl[1]), "=r"(v.hl[0])
: "Z"(*(const uint32_t*)p), "Z"(*((const uint32_t*)p+1)));
return v.v;
}
 
#define AV_WL64 AV_WL64
static av_always_inline void AV_WL64(void *p, uint64_t v)
{
union { uint64_t v; uint32_t hl[2]; } vv = { v };
__asm__ ("stwbrx %2, %y0 \n\t"
"stwbrx %3, %y1 \n\t"
: "=Z"(*(uint32_t*)p), "=Z"(*((uint32_t*)p+1))
: "r"(vv.hl[1]), "r"(vv.hl[0]));
}
 
#endif /* HAVE_LDBRX */
 
#endif /* HAVE_XFORM_ASM */
 
/*
* GCC fails miserably on the packed struct version which is used by
* default, so we override it here.
*/
 
#define AV_RB64(p) (*(const uint64_t *)(p))
#define AV_WB64(p, v) (*(uint64_t *)(p) = (v))
 
#endif /* AVUTIL_PPC_INTREADWRITE_H */
/contrib/sdk/sources/ffmpeg/libavutil/ppc/timer.h
0,0 → 1,48
/*
* Copyright (c) 2005 Luca Barbato <lu_zero@gentoo.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
*/
 
#ifndef AVUTIL_PPC_TIMER_H
#define AVUTIL_PPC_TIMER_H
 
#include <stdint.h>
 
#include "config.h"
 
#define AV_READ_TIME read_time
 
static inline uint64_t read_time(void)
{
uint32_t tbu, tbl, temp;
 
/* from section 2.2.1 of the 32-bit PowerPC PEM */
__asm__ volatile(
"mftbu %2\n"
"mftb %0\n"
"mftbu %1\n"
"cmpw %2,%1\n"
"bne $-0x10\n"
: "=r"(tbl), "=r"(tbu), "=r"(temp)
:
: "cc");
 
return (((uint64_t)tbu)<<32) | (uint64_t)tbl;
}
 
#endif /* AVUTIL_PPC_TIMER_H */
/contrib/sdk/sources/ffmpeg/libavutil/ppc/types_altivec.h
0,0 → 1,47
/*
* Copyright (c) 2006 Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* 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
*/
 
#ifndef AVUTIL_PPC_TYPES_ALTIVEC_H
#define AVUTIL_PPC_TYPES_ALTIVEC_H
 
/***********************************************************************
* Vector types
**********************************************************************/
#define vec_u8 vector unsigned char
#define vec_s8 vector signed char
#define vec_u16 vector unsigned short
#define vec_s16 vector signed short
#define vec_u32 vector unsigned int
#define vec_s32 vector signed int
#define vec_f vector float
 
/***********************************************************************
* Null vector
**********************************************************************/
#define LOAD_ZERO const vec_u8 zerov = vec_splat_u8( 0 )
 
#define zero_u8v (vec_u8) zerov
#define zero_s8v (vec_s8) zerov
#define zero_u16v (vec_u16) zerov
#define zero_s16v (vec_s16) zerov
#define zero_u32v (vec_u32) zerov
#define zero_s32v (vec_s32) zerov
 
#endif /* AVUTIL_PPC_TYPES_ALTIVEC_H */
/contrib/sdk/sources/ffmpeg/libavutil/ppc/util_altivec.h
0,0 → 1,122
/*
* 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
*/
 
/**
* @file
* Contains misc utility macros and inline functions
*/
 
#ifndef AVUTIL_PPC_UTIL_ALTIVEC_H
#define AVUTIL_PPC_UTIL_ALTIVEC_H
 
#include <stdint.h>
 
#include "config.h"
 
#if HAVE_ALTIVEC_H
#include <altivec.h>
#endif
 
#include "types_altivec.h"
 
#if HAVE_ALTIVEC
 
// used to build registers permutation vectors (vcprm)
// the 's' are for words in the _s_econd vector
#define WORD_0 0x00,0x01,0x02,0x03
#define WORD_1 0x04,0x05,0x06,0x07
#define WORD_2 0x08,0x09,0x0a,0x0b
#define WORD_3 0x0c,0x0d,0x0e,0x0f
#define WORD_s0 0x10,0x11,0x12,0x13
#define WORD_s1 0x14,0x15,0x16,0x17
#define WORD_s2 0x18,0x19,0x1a,0x1b
#define WORD_s3 0x1c,0x1d,0x1e,0x1f
 
#define vcprm(a,b,c,d) (const vector unsigned char){WORD_ ## a, WORD_ ## b, WORD_ ## c, WORD_ ## d}
#define vcii(a,b,c,d) (const vector float){FLOAT_ ## a, FLOAT_ ## b, FLOAT_ ## c, FLOAT_ ## d}
 
// vcprmle is used to keep the same index as in the SSE version.
// it's the same as vcprm, with the index inversed
// ('le' is Little Endian)
#define vcprmle(a,b,c,d) vcprm(d,c,b,a)
 
// used to build inverse/identity vectors (vcii)
// n is _n_egative, p is _p_ositive
#define FLOAT_n -1.
#define FLOAT_p 1.
 
 
// Transpose 8x8 matrix of 16-bit elements (in-place)
#define TRANSPOSE8(a,b,c,d,e,f,g,h) \
do { \
vector signed short A1, B1, C1, D1, E1, F1, G1, H1; \
vector signed short A2, B2, C2, D2, E2, F2, G2, H2; \
\
A1 = vec_mergeh (a, e); \
B1 = vec_mergel (a, e); \
C1 = vec_mergeh (b, f); \
D1 = vec_mergel (b, f); \
E1 = vec_mergeh (c, g); \
F1 = vec_mergel (c, g); \
G1 = vec_mergeh (d, h); \
H1 = vec_mergel (d, h); \
\
A2 = vec_mergeh (A1, E1); \
B2 = vec_mergel (A1, E1); \
C2 = vec_mergeh (B1, F1); \
D2 = vec_mergel (B1, F1); \
E2 = vec_mergeh (C1, G1); \
F2 = vec_mergel (C1, G1); \
G2 = vec_mergeh (D1, H1); \
H2 = vec_mergel (D1, H1); \
\
a = vec_mergeh (A2, E2); \
b = vec_mergel (A2, E2); \
c = vec_mergeh (B2, F2); \
d = vec_mergel (B2, F2); \
e = vec_mergeh (C2, G2); \
f = vec_mergel (C2, G2); \
g = vec_mergeh (D2, H2); \
h = vec_mergel (D2, H2); \
} while (0)
 
 
/** @brief loads unaligned vector @a *src with offset @a offset
and returns it */
static inline vector unsigned char unaligned_load(int offset, uint8_t *src)
{
register vector unsigned char first = vec_ld(offset, src);
register vector unsigned char second = vec_ld(offset+15, src);
register vector unsigned char mask = vec_lvsl(offset, src);
return vec_perm(first, second, mask);
}
 
/**
* loads vector known misalignment
* @param perm_vec the align permute vector to combine the two loads from lvsl
*/
static inline vec_u8 load_with_perm_vec(int offset, uint8_t *src, vec_u8 perm_vec)
{
vec_u8 a = vec_ld(offset, src);
vec_u8 b = vec_ld(offset+15, src);
return vec_perm(a, b, perm_vec);
}
 
#endif /* HAVE_ALTIVEC */
 
#endif /* AVUTIL_PPC_UTIL_ALTIVEC_H */