aabc2/KOS_qrcodes
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

ffmpeg-2.8.5

Browse Source 
git-svn-id: svn://kolibrios.org@6147 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge)
2016-02-05 22:08:02 +00:00
parent a08f61ddb9
commit a4b787f4b8
5429 changed files with 1356786 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/Makefile Normal file
View File

@@ -0,0 +1,6 @@
OBJS += ppc/cpu.o \
ppc/float_dsp_init.o \
ALTIVEC-OBJS += ppc/float_dsp_altivec.o \
VSX-OBJS += ppc/float_dsp_vsx.o \

150
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/cpu.c Normal file
View File

@@ -0,0 +1,150 @@
/*
* 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"
#ifdef __APPLE__
#include <sys/sysctl.h>
#elif defined(__linux__)
#include <asm/cputable.h>
#include <linux/auxvec.h>
#include <fcntl.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#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/avassert.h"
#include "libavutil/cpu.h"
#include "libavutil/cpu_internal.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 defined(__linux__)
// The linux kernel could have the altivec support disabled
// even if the cpu has it.
int i, ret = 0;
int fd = open("/proc/self/auxv", O_RDONLY);
unsigned long buf[64] = { 0 };
ssize_t count;
if (fd < 0)
return 0;
while ((count = read(fd, buf, sizeof(buf))) > 0) {
for (i = 0; i < count / sizeof(*buf); i += 2) {
if (buf[i] == AT_NULL)
goto out;
if (buf[i] == AT_HWCAP) {
if (buf[i + 1] & PPC_FEATURE_HAS_ALTIVEC)
ret = AV_CPU_FLAG_ALTIVEC;
#ifdef PPC_FEATURE_HAS_VSX
if (buf[i + 1] & PPC_FEATURE_HAS_VSX)
ret |= AV_CPU_FLAG_VSX;
#endif
#ifdef PPC_FEATURE_ARCH_2_07
if (buf[i + 1] & PPC_FEATURE_HAS_POWER8)
ret |= AV_CPU_FLAG_POWER8;
#endif
if (ret & AV_CPU_FLAG_VSX)
av_assert0(ret & AV_CPU_FLAG_ALTIVEC);
goto out;
}
}
}
out:
close(fd);
return ret;
#elif CONFIG_RUNTIME_CPUDETECT && defined(__linux__)
#define PVR_G4_7400 0x000C
#define PVR_G5_970 0x0039
#define PVR_G5_970FX 0x003C
#define PVR_G5_970MP 0x0044
#define PVR_G5_970GX 0x0045
#define PVR_POWER6 0x003E
#define PVR_POWER7 0x003F
#define PVR_POWER8 0x004B
#define PVR_CELL_PPU 0x0070
int ret = 0;
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 == PVR_G4_7400 ||
proc_ver == PVR_G5_970 ||
proc_ver == PVR_G5_970FX ||
proc_ver == PVR_G5_970MP ||
proc_ver == PVR_G5_970GX ||
proc_ver == PVR_POWER6 ||
proc_ver == PVR_POWER7 ||
proc_ver == PVR_POWER8 ||
proc_ver == PVR_CELL_PPU)
ret = AV_CPU_FLAG_ALTIVEC;
if (proc_ver == PVR_POWER7 ||
proc_ver == PVR_POWER8)
ret |= AV_CPU_FLAG_VSX;
if (proc_ver == PVR_POWER8)
ret |= AV_CPU_FLAG_POWER8;
return ret;
#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;
}

30
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/cpu.h Normal file
View File

@@ -0,0 +1,30 @@
/*
* 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)
#define PPC_VSX(flags) CPUEXT(flags, VSX)
#define PPC_POWER8(flags) CPUEXT(flags, POWER8)
#endif /* AVUTIL_PPC_CPU_H */

122
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/float_dsp_altivec.c Normal file
View File

@@ -0,0 +1,122 @@
/*
* 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;
vec_f d0, d1, s, zero = (vec_f)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)
{
vec_f zero, t0, t1, s0, s1, wi, wj;
const vec_u8 reverse = vcprm(3, 2, 1, 0);
int i, j;
dst += len;
win += len;
src0 += len;
zero = (vec_f)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;
vec_f d, ss0, ss1, ss2, t0, t1, edges;
for (i = 0; i < len - 3; i += 4) {
t0 = vec_ld(0, dst + i);
t1 = vec_ld(15, dst + i);
ss0 = vec_ld(0, src0 + i);
ss1 = vec_ld(0, src1 + i);
ss2 = vec_ld(0, src2 + i);
edges = vec_perm(t1, t0, vcprm(0, 1, 2, 3));
d = vec_madd(ss0, ss1, ss2);
t1 = vec_perm(d, edges, vcprm(s0,s1,s2,s3));
t0 = vec_perm(edges, d, vcprm(s0,s1,s2,s3));
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;
vec_f d, s0, s1, h0, l0, s2, s3;
vec_f zero = (vec_f)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);
}
}

38
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/float_dsp_altivec.h Normal file
View File

@@ -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 */

52
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/float_dsp_init.c Normal file
View File

@@ -0,0 +1,52 @@
/*
* 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"
#include "float_dsp_vsx.h"
av_cold void ff_float_dsp_init_ppc(AVFloatDSPContext *fdsp, int bit_exact)
{
if (PPC_ALTIVEC(av_get_cpu_flags())) {
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;
}
}
// The disabled function below are near identical to altivec and have
// been disabled to reduce code duplication
if (PPC_VSX(av_get_cpu_flags())) {
// fdsp->vector_fmul = ff_vector_fmul_vsx;
fdsp->vector_fmul_add = ff_vector_fmul_add_vsx;
// fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_vsx;
// if (!bit_exact) {
// fdsp->vector_fmul_window = ff_vector_fmul_window_vsx;
// }
}
}

117
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/float_dsp_vsx.c Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright (c) 2015 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_vsx.h"
void ff_vector_fmul_vsx(float *dst,
const float *src0, const float *src1,
int len)
{
int i;
vec_f d0, d1, zero = (vec_f)vec_splat_u32(0);
for (i = 0; i < len - 7; i += 8) {
d0 = vec_vsx_ld( 0, src0 + i);
d1 = vec_vsx_ld(16, src0 + i);
d0 = vec_madd(d0, vec_vsx_ld( 0, src1 + i), zero);
d1 = vec_madd(d1, vec_vsx_ld(16, src1 + i), zero);
vec_vsx_st(d0, 0, dst + i);
vec_vsx_st(d1, 16, dst + i);
}
}
void ff_vector_fmul_window_vsx(float *dst, const float *src0,
const float *src1, const float *win,
int len)
{
vec_f zero, t0, t1, s0, s1, wi, wj;
const vec_u8 reverse = vcprm(3, 2, 1, 0);
int i, j;
dst += len;
win += len;
src0 += len;
zero = (vec_f)vec_splat_u32(0);
for (i = -len * 4, j = len * 4 - 16; i < 0; i += 16, j -= 16) {
s0 = vec_vsx_ld(i, src0);
s1 = vec_vsx_ld(j, src1);
wi = vec_vsx_ld(i, win);
wj = vec_vsx_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_vsx_st(t0, i, dst);
vec_vsx_st(t1, j, dst);
}
}
void ff_vector_fmul_add_vsx(float *dst, const float *src0,
const float *src1, const float *src2,
int len)
{
int i;
vec_f d, s0, s1, s2;
for (i = 0; i < len - 3; i += 4) {
s0 = vec_vsx_ld(0, src0 + i);
s1 = vec_vsx_ld(0, src1 + i);
s2 = vec_vsx_ld(0, src2 + i);
d = vec_madd(s0, s1, s2);
vec_vsx_st(d, 0, dst + i);
}
}
void ff_vector_fmul_reverse_vsx(float *dst, const float *src0,
const float *src1, int len)
{
int i;
vec_f d, s0, s1, h0, l0, s2, s3;
vec_f zero = (vec_f)vec_splat_u32(0);
src1 += len - 4;
for (i = 0; i < len - 7; i += 8) {
s1 = vec_vsx_ld(0, src1 - i); // [a,b,c,d]
s0 = vec_vsx_ld(0, src0 + i);
l0 = vec_mergel(s1, s1); // [c,c,d,d]
s3 = vec_vsx_ld(-16, src1 - i);
h0 = vec_mergeh(s1, s1); // [a,a,b,b]
s2 = vec_vsx_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_vsx_st(d, 0, dst + i);
s3 = vec_mergeh(vec_mergel(l0, h0),
vec_mergeh(l0, h0));
d = vec_madd(s2, s3, zero);
vec_vsx_st(d, 16, dst + i);
}
}

38
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/float_dsp_vsx.h Normal file
View File

@@ -0,0 +1,38 @@
/*
* Copyright (c) 2015 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_VSX_H
#define AVUTIL_PPC_FLOAT_DSP_VSX_H
void ff_vector_fmul_vsx(float *dst, const float *src0,
const float *src1, int len);
void ff_vector_fmul_window_vsx(float *dst, const float *src0,
const float *src1, const float *win,
int len);
void ff_vector_fmul_add_vsx(float *dst, const float *src0,
const float *src1, const float *src2,
int len);
void ff_vector_fmul_reverse_vsx(float *dst, const float *src0,
const float *src1, int len);
#endif /* AVUTIL_PPC_FLOAT_DSP_VSX_H */

110
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/intreadwrite.h Normal file
View File

@@ -0,0 +1,110 @@
/*
* 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
#if HAVE_BIGENDIAN
#define AV_RL16 av_read_bswap16
#define AV_WL16 av_write_bswap16
#define AV_RL32 av_read_bswap32
#define AV_WL32 av_write_bswap32
#define AV_RL64 av_read_bswap64
#define AV_WL64 av_write_bswap64
#else
#define AV_RB16 av_read_bswap16
#define AV_WB16 av_write_bswap16
#define AV_RB32 av_read_bswap32
#define AV_WB32 av_write_bswap32
#define AV_RB64 av_read_bswap64
#define AV_WB64 av_write_bswap64
#endif
static av_always_inline uint16_t av_read_bswap16(const void *p)
{
uint16_t v;
__asm__ ("lhbrx %0, %y1" : "=r"(v) : "Z"(*(const uint16_t*)p));
return v;
}
static av_always_inline void av_write_bswap16(void *p, uint16_t v)
{
__asm__ ("sthbrx %1, %y0" : "=Z"(*(uint16_t*)p) : "r"(v));
}
static av_always_inline uint32_t av_read_bswap32(const void *p)
{
uint32_t v;
__asm__ ("lwbrx %0, %y1" : "=r"(v) : "Z"(*(const uint32_t*)p));
return v;
}
static av_always_inline void av_write_bswap32(void *p, uint32_t v)
{
__asm__ ("stwbrx %1, %y0" : "=Z"(*(uint32_t*)p) : "r"(v));
}
#if HAVE_LDBRX
static av_always_inline uint64_t av_read_bswap64(const void *p)
{
uint64_t v;
__asm__ ("ldbrx %0, %y1" : "=r"(v) : "Z"(*(const uint64_t*)p));
return v;
}
static av_always_inline void av_write_bswap64(void *p, uint64_t v)
{
__asm__ ("stdbrx %1, %y0" : "=Z"(*(uint64_t*)p) : "r"(v));
}
#else
static av_always_inline uint64_t av_read_bswap64(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;
}
static av_always_inline void av_write_bswap64(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 */
#endif /* AVUTIL_PPC_INTREADWRITE_H */

48
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/timer.h Normal file
View File

@@ -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 */

47
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/types_altivec.h Normal file
View File

@@ -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 */

177
contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavutil/ppc/util_altivec.h Normal file
View File

@@ -0,0 +1,177 @@
/*
* 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 vec_u8){WORD_ ## a, WORD_ ## b, WORD_ ## c, WORD_ ## d}
#define SWP_W2S0 0x02,0x03,0x00,0x01
#define SWP_W2S1 0x06,0x07,0x04,0x05
#define SWP_W2S2 0x0a,0x0b,0x08,0x09
#define SWP_W2S3 0x0e,0x0f,0x0c,0x0d
#define SWP_W2Ss0 0x12,0x13,0x10,0x11
#define SWP_W2Ss1 0x16,0x17,0x14,0x15
#define SWP_W2Ss2 0x1a,0x1b,0x18,0x19
#define SWP_W2Ss3 0x1e,0x1f,0x1c,0x1d
#define vcswapi2s(a,b,c,d) (const vector unsigned char){SWP_W2S ## a, SWP_W2S ## b, SWP_W2S ## c, SWP_W2S ## d}
#define vcswapc() \
(const vector unsigned char){0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00}
// Transpose 8x8 matrix of 16-bit elements (in-place)
#define TRANSPOSE8(a,b,c,d,e,f,g,h) \
do { \
vec_s16 A1, B1, C1, D1, E1, F1, G1, H1; \
vec_s16 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)
#if HAVE_BIGENDIAN
#define VEC_LD(offset,b) \
vec_perm(vec_ld(offset, b), vec_ld((offset)+15, b), vec_lvsl(offset, b))
#else
#define VEC_LD(offset,b) \
vec_vsx_ld(offset, b)
#endif
/** @brief loads unaligned vector @a *src with offset @a offset
and returns it */
#if HAVE_BIGENDIAN
static inline vec_u8 unaligned_load(int offset, const uint8_t *src)
{
register vec_u8 first = vec_ld(offset, src);
register vec_u8 second = vec_ld(offset + 15, src);
register vec_u8 mask = vec_lvsl(offset, src);
return vec_perm(first, second, mask);
}
static inline vec_u8 load_with_perm_vec(int offset, const 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);
}
#else
#define unaligned_load(a,b) VEC_LD(a,b)
#define load_with_perm_vec(a,b,c) VEC_LD(a,b)
#endif
/**
* loads vector known misalignment
* @param perm_vec the align permute vector to combine the two loads from lvsl
*/
#define vec_unaligned_load(b) VEC_LD(0, b)
#if HAVE_BIGENDIAN
#define VEC_MERGEH(a, b) vec_mergeh(a, b)
#define VEC_MERGEL(a, b) vec_mergel(a, b)
#else
#define VEC_MERGEH(a, b) vec_mergeh(b, a)
#define VEC_MERGEL(a, b) vec_mergel(b, a)
#endif
#if HAVE_BIGENDIAN
#define VEC_ST(a,b,c) vec_st(a,b,c)
#else
#define VEC_ST(a,b,c) vec_vsx_st(a,b,c)
#endif
#if HAVE_BIGENDIAN
#define VEC_SPLAT16(a,b) vec_splat((vec_s16)(a), b)
#else
#define VEC_SPLAT16(a,b) vec_splat((vec_s16)(vec_perm(a, a, vcswapi2s(0,1,2,3))), b)
#endif
#if HAVE_BIGENDIAN
#define VEC_SLD16(a,b,c) vec_sld(a, b, c)
#else
#define VEC_SLD16(a,b,c) vec_sld(b, a, c)
#endif
#endif /* HAVE_ALTIVEC */
#if HAVE_VSX
#if HAVE_BIGENDIAN
#define vsx_ld_u8_s16(off, p) \
((vec_s16)vec_mergeh((vec_u8)vec_splat_u8(0), \
(vec_u8)vec_vsx_ld((off), (p))))
#else
#define vsx_ld_u8_s16(off, p) \
((vec_s16)vec_mergeh((vec_u8)vec_vsx_ld((off), (p)), \
(vec_u8)vec_splat_u8(0)))
#endif /* HAVE_BIGENDIAN */
#endif /* HAVE_VSX */
#endif /* AVUTIL_PPC_UTIL_ALTIVEC_H */