From eef478a8f032626eeb2c7b6f919d2de0729a5de9 Mon Sep 17 00:00:00 2001 From: Jakub Bogusz Date: Sun, 5 Dec 2004 13:09:08 +0000 Subject: [PATCH] - updated for 0.7.41 (almost obsolete now, only small changes remain) Changed files: avifile-ffmpeg-alpha.patch -> 1.4 avifile-ffmpeg-ppc.patch -> 1.5 --- avifile-ffmpeg-alpha.patch | 1289 +-------------- avifile-ffmpeg-ppc.patch | 3140 ------------------------------------ 2 files changed, 11 insertions(+), 4418 deletions(-) diff --git a/avifile-ffmpeg-alpha.patch b/avifile-ffmpeg-alpha.patch index 393b032..70bccae 100644 --- a/avifile-ffmpeg-alpha.patch +++ b/avifile-ffmpeg-alpha.patch @@ -1,508 +1,6 @@ -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/asm.h avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/asm.h ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/asm.h 2002-10-16 09:26:12.000000000 +0200 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/asm.h 2003-09-28 17:26:39.000000000 +0200 -@@ -42,14 +42,14 @@ - #define AMASK_CIX (1 << 2) - #define AMASK_MVI (1 << 8) - --inline static uint64_t BYTE_VEC(uint64_t x) -+static inline uint64_t BYTE_VEC(uint64_t x) - { - x |= x << 8; - x |= x << 16; - x |= x << 32; - return x; - } --inline static uint64_t WORD_VEC(uint64_t x) -+static inline uint64_t WORD_VEC(uint64_t x) - { - x |= x << 16; - x |= x << 32; -@@ -63,27 +63,15 @@ - #define sextw(x) ((int16_t) (x)) - - #ifdef __GNUC__ --#define ASM_ACCEPT_MVI asm (".arch pca56") - struct unaligned_long { uint64_t l; } __attribute__((packed)); - #define ldq_u(p) (*(const uint64_t *) (((uint64_t) (p)) & ~7ul)) - #define uldq(a) (((const struct unaligned_long *) (a))->l) - --#if GNUC_PREREQ(3,0) --/* Unfortunately, __builtin_prefetch is slightly buggy on Alpha. The -- defines here are kludged so we still get the right -- instruction. This needs to be adapted as soon as gcc is fixed. */ --# define prefetch(p) __builtin_prefetch((p), 0, 1) --# define prefetch_en(p) __builtin_prefetch((p), 1, 1) --# define prefetch_m(p) __builtin_prefetch((p), 0, 0) --# define prefetch_men(p) __builtin_prefetch((p), 1, 0) --#else --# define prefetch(p) asm volatile("ldl $31,%0" : : "m"(*(const char *) (p)) : "memory") --# define prefetch_en(p) asm volatile("ldq $31,%0" : : "m"(*(const char *) (p)) : "memory") --# define prefetch_m(p) asm volatile("lds $f31,%0" : : "m"(*(const char *) (p)) : "memory") --# define prefetch_men(p) asm volatile("ldt $f31,%0" : : "m"(*(const char *) (p)) : "memory") --#endif -- - #if GNUC_PREREQ(3,3) -+#define prefetch(p) __builtin_prefetch((p), 0, 1) -+#define prefetch_en(p) __builtin_prefetch((p), 0, 0) -+#define prefetch_m(p) __builtin_prefetch((p), 1, 1) -+#define prefetch_men(p) __builtin_prefetch((p), 1, 0) - #define cmpbge __builtin_alpha_cmpbge - /* Avoid warnings. */ - #define extql(a, b) __builtin_alpha_extql(a, (uint64_t) (b)) -@@ -94,6 +82,24 @@ - #define amask __builtin_alpha_amask - #define implver __builtin_alpha_implver - #define rpcc __builtin_alpha_rpcc -+#else -+#define prefetch(p) asm volatile("ldl $31,%0" : : "m"(*(const char *) (p)) : "memory") -+#define prefetch_en(p) asm volatile("ldq $31,%0" : : "m"(*(const char *) (p)) : "memory") -+#define prefetch_m(p) asm volatile("lds $f31,%0" : : "m"(*(const char *) (p)) : "memory") -+#define prefetch_men(p) asm volatile("ldt $f31,%0" : : "m"(*(const char *) (p)) : "memory") -+#define cmpbge(a, b) ({ uint64_t __r; asm ("cmpbge %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define extql(a, b) ({ uint64_t __r; asm ("extql %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define extwl(a, b) ({ uint64_t __r; asm ("extwl %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define extqh(a, b) ({ uint64_t __r; asm ("extqh %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define zap(a, b) ({ uint64_t __r; asm ("zap %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define zapnot(a, b) ({ uint64_t __r; asm ("zapnot %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) -+#define amask(a) ({ uint64_t __r; asm ("amask %1,%0" : "=r" (__r) : "rI" (a)); __r; }) -+#define implver() ({ uint64_t __r; asm ("implver %0" : "=r" (__r)); __r; }) -+#define rpcc() ({ uint64_t __r; asm volatile ("rpcc %0" : "=r" (__r)); __r; }) -+#endif -+#define wh64(p) asm volatile("wh64 (%0)" : : "r"(p) : "memory") -+ -+#if GNUC_PREREQ(3,3) && defined(__alpha_max__) - #define minub8 __builtin_alpha_minub8 - #define minsb8 __builtin_alpha_minsb8 - #define minuw4 __builtin_alpha_minuw4 -@@ -108,34 +114,24 @@ - #define unpkbl __builtin_alpha_unpkbl - #define unpkbw __builtin_alpha_unpkbw - #else --#define cmpbge(a, b) ({ uint64_t __r; asm ("cmpbge %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define extql(a, b) ({ uint64_t __r; asm ("extql %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define extwl(a, b) ({ uint64_t __r; asm ("extwl %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define extqh(a, b) ({ uint64_t __r; asm ("extqh %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define zap(a, b) ({ uint64_t __r; asm ("zap %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define zapnot(a, b) ({ uint64_t __r; asm ("zapnot %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) --#define amask(a) ({ uint64_t __r; asm ("amask %1,%0" : "=r" (__r) : "rI" (a)); __r; }) --#define implver() ({ uint64_t __r; asm ("implver %0" : "=r" (__r)); __r; }) --#define rpcc() ({ uint64_t __r; asm volatile ("rpcc %0" : "=r" (__r)); __r; }) --#define minub8(a, b) ({ uint64_t __r; asm ("minub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define minsb8(a, b) ({ uint64_t __r; asm ("minsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define minuw4(a, b) ({ uint64_t __r; asm ("minuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define minsw4(a, b) ({ uint64_t __r; asm ("minsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define maxub8(a, b) ({ uint64_t __r; asm ("maxub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define maxsb8(a, b) ({ uint64_t __r; asm ("maxsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define maxuw4(a, b) ({ uint64_t __r; asm ("maxuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define maxsw4(a, b) ({ uint64_t __r; asm ("maxsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) --#define perr(a, b) ({ uint64_t __r; asm ("perr %r1,%r2,%0" : "=r" (__r) : "%rJ" (a), "rJ" (b)); __r; }) --#define pklb(a) ({ uint64_t __r; asm ("pklb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) --#define pkwb(a) ({ uint64_t __r; asm ("pkwb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) --#define unpkbl(a) ({ uint64_t __r; asm ("unpkbl %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) --#define unpkbw(a) ({ uint64_t __r; asm ("unpkbw %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -+#define minub8(a, b) ({ uint64_t __r; asm (".arch ev6; minub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define minsb8(a, b) ({ uint64_t __r; asm (".arch ev6; minsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define minuw4(a, b) ({ uint64_t __r; asm (".arch ev6; minuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define minsw4(a, b) ({ uint64_t __r; asm (".arch ev6; minsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define maxub8(a, b) ({ uint64_t __r; asm (".arch ev6; maxub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define maxsb8(a, b) ({ uint64_t __r; asm (".arch ev6; maxsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define maxuw4(a, b) ({ uint64_t __r; asm (".arch ev6; maxuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define maxsw4(a, b) ({ uint64_t __r; asm (".arch ev6; maxsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -+#define perr(a, b) ({ uint64_t __r; asm (".arch ev6; perr %r1,%r2,%0" : "=r" (__r) : "%rJ" (a), "rJ" (b)); __r; }) -+#define pklb(a) ({ uint64_t __r; asm (".arch ev6; pklb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -+#define pkwb(a) ({ uint64_t __r; asm (".arch ev6; pkwb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -+#define unpkbl(a) ({ uint64_t __r; asm (".arch ev6; unpkbl %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -+#define unpkbw(a) ({ uint64_t __r; asm (".arch ev6; unpkbw %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) - #endif - - #elif defined(__DECC) /* Digital/Compaq/hp "ccc" compiler */ - - #include --#define ASM_ACCEPT_MVI - #define ldq_u(a) asm ("ldq_u %v0,0(%a0)", a) - #define uldq(a) (*(const __unaligned uint64_t *) (a)) - #define cmpbge(a, b) asm ("cmpbge %a0,%a1,%v0", a, b) -@@ -160,6 +156,7 @@ - #define pkwb(a) asm ("pkwb %a0,%v0", a) - #define unpkbl(a) asm ("unpkbl %a0,%v0", a) - #define unpkbw(a) asm ("unpkbw %a0,%v0", a) -+#define wh64(a) asm ("wh64 %a0", a) - - #else - #error "Unknown compiler!" -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/dsputil_alpha.c avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/dsputil_alpha.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/dsputil_alpha.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/dsputil_alpha.c 2003-09-28 17:26:39.000000000 +0200 -@@ -0,0 +1,364 @@ -+/* -+ * Alpha optimized DSP utils -+ * Copyright (c) 2002 Falk Hueffner -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "asm.h" -+#include "../dsputil.h" -+ -+extern void simple_idct_axp(DCTELEM *block); -+extern void simple_idct_put_axp(uint8_t *dest, int line_size, DCTELEM *block); -+extern void simple_idct_add_axp(uint8_t *dest, int line_size, DCTELEM *block); -+ -+void put_pixels_axp_asm(uint8_t *block, const uint8_t *pixels, -+ int line_size, int h); -+void put_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+void add_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+void (*put_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+void (*add_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+ -+void get_pixels_mvi(DCTELEM *restrict block, -+ const uint8_t *restrict pixels, int line_size); -+void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, -+ int stride); -+int pix_abs8x8_mvi(uint8_t *pix1, uint8_t *pix2, int line_size); -+int pix_abs16x16_mvi_asm(uint8_t *pix1, uint8_t *pix2, int line_size); -+int pix_abs16x16_x2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size); -+int pix_abs16x16_y2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size); -+int pix_abs16x16_xy2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size); -+ -+#if 0 -+/* These functions were the base for the optimized assembler routines, -+ and remain here for documentation purposes. */ -+static void put_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels, -+ int line_size) -+{ -+ int i = 8; -+ uint64_t clampmask = zap(-1, 0xaa); /* 0x00ff00ff00ff00ff */ -+ -+ do { -+ uint64_t shorts0, shorts1; -+ -+ shorts0 = ldq(block); -+ shorts0 = maxsw4(shorts0, 0); -+ shorts0 = minsw4(shorts0, clampmask); -+ stl(pkwb(shorts0), pixels); -+ -+ shorts1 = ldq(block + 4); -+ shorts1 = maxsw4(shorts1, 0); -+ shorts1 = minsw4(shorts1, clampmask); -+ stl(pkwb(shorts1), pixels + 4); -+ -+ pixels += line_size; -+ block += 8; -+ } while (--i); -+} -+ -+void add_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels, -+ int line_size) -+{ -+ int h = 8; -+ /* Keep this function a leaf function by generating the constants -+ manually (mainly for the hack value ;-). */ -+ uint64_t clampmask = zap(-1, 0xaa); /* 0x00ff00ff00ff00ff */ -+ uint64_t signmask = zap(-1, 0x33); -+ signmask ^= signmask >> 1; /* 0x8000800080008000 */ -+ -+ do { -+ uint64_t shorts0, pix0, signs0; -+ uint64_t shorts1, pix1, signs1; -+ -+ shorts0 = ldq(block); -+ shorts1 = ldq(block + 4); -+ -+ pix0 = unpkbw(ldl(pixels)); -+ /* Signed subword add (MMX paddw). */ -+ signs0 = shorts0 & signmask; -+ shorts0 &= ~signmask; -+ shorts0 += pix0; -+ shorts0 ^= signs0; -+ /* Clamp. */ -+ shorts0 = maxsw4(shorts0, 0); -+ shorts0 = minsw4(shorts0, clampmask); -+ -+ /* Next 4. */ -+ pix1 = unpkbw(ldl(pixels + 4)); -+ signs1 = shorts1 & signmask; -+ shorts1 &= ~signmask; -+ shorts1 += pix1; -+ shorts1 ^= signs1; -+ shorts1 = maxsw4(shorts1, 0); -+ shorts1 = minsw4(shorts1, clampmask); -+ -+ stl(pkwb(shorts0), pixels); -+ stl(pkwb(shorts1), pixels + 4); -+ -+ pixels += line_size; -+ block += 8; -+ } while (--h); -+} -+#endif -+ -+static void clear_blocks_axp(DCTELEM *blocks) { -+ uint64_t *p = (uint64_t *) blocks; -+ int n = sizeof(DCTELEM) * 6 * 64; -+ -+ do { -+ p[0] = 0; -+ p[1] = 0; -+ p[2] = 0; -+ p[3] = 0; -+ p[4] = 0; -+ p[5] = 0; -+ p[6] = 0; -+ p[7] = 0; -+ p += 8; -+ n -= 8 * 8; -+ } while (n); -+} -+ -+static inline uint64_t avg2_no_rnd(uint64_t a, uint64_t b) -+{ -+ return (a & b) + (((a ^ b) & BYTE_VEC(0xfe)) >> 1); -+} -+ -+static inline uint64_t avg2(uint64_t a, uint64_t b) -+{ -+ return (a | b) - (((a ^ b) & BYTE_VEC(0xfe)) >> 1); -+} -+ -+#if 0 -+/* The XY2 routines basically utilize this scheme, but reuse parts in -+ each iteration. */ -+static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4) -+{ -+ uint64_t r1 = ((l1 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l2 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l3 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l4 & ~BYTE_VEC(0x03)) >> 2); -+ uint64_t r2 = (( (l1 & BYTE_VEC(0x03)) -+ + (l2 & BYTE_VEC(0x03)) -+ + (l3 & BYTE_VEC(0x03)) -+ + (l4 & BYTE_VEC(0x03)) -+ + BYTE_VEC(0x02)) >> 2) & BYTE_VEC(0x03); -+ return r1 + r2; -+} -+#endif -+ -+#define OP(LOAD, STORE) \ -+ do { \ -+ STORE(LOAD(pixels), block); \ -+ pixels += line_size; \ -+ block += line_size; \ -+ } while (--h) -+ -+#define OP_X2(LOAD, STORE) \ -+ do { \ -+ uint64_t pix1, pix2; \ -+ \ -+ pix1 = LOAD(pixels); \ -+ pix2 = pix1 >> 8 | ((uint64_t) pixels[8] << 56); \ -+ STORE(AVG2(pix1, pix2), block); \ -+ pixels += line_size; \ -+ block += line_size; \ -+ } while (--h) -+ -+#define OP_Y2(LOAD, STORE) \ -+ do { \ -+ uint64_t pix = LOAD(pixels); \ -+ do { \ -+ uint64_t next_pix; \ -+ \ -+ pixels += line_size; \ -+ next_pix = LOAD(pixels); \ -+ STORE(AVG2(pix, next_pix), block); \ -+ block += line_size; \ -+ pix = next_pix; \ -+ } while (--h); \ -+ } while (0) -+ -+#define OP_XY2(LOAD, STORE) \ -+ do { \ -+ uint64_t pix1 = LOAD(pixels); \ -+ uint64_t pix2 = pix1 >> 8 | ((uint64_t) pixels[8] << 56); \ -+ uint64_t pix_l = (pix1 & BYTE_VEC(0x03)) \ -+ + (pix2 & BYTE_VEC(0x03)); \ -+ uint64_t pix_h = ((pix1 & ~BYTE_VEC(0x03)) >> 2) \ -+ + ((pix2 & ~BYTE_VEC(0x03)) >> 2); \ -+ \ -+ do { \ -+ uint64_t npix1, npix2; \ -+ uint64_t npix_l, npix_h; \ -+ uint64_t avg; \ -+ \ -+ pixels += line_size; \ -+ npix1 = LOAD(pixels); \ -+ npix2 = npix1 >> 8 | ((uint64_t) pixels[8] << 56); \ -+ npix_l = (npix1 & BYTE_VEC(0x03)) \ -+ + (npix2 & BYTE_VEC(0x03)); \ -+ npix_h = ((npix1 & ~BYTE_VEC(0x03)) >> 2) \ -+ + ((npix2 & ~BYTE_VEC(0x03)) >> 2); \ -+ avg = (((pix_l + npix_l + AVG4_ROUNDER) >> 2) & BYTE_VEC(0x03)) \ -+ + pix_h + npix_h; \ -+ STORE(avg, block); \ -+ \ -+ block += line_size; \ -+ pix_l = npix_l; \ -+ pix_h = npix_h; \ -+ } while (--h); \ -+ } while (0) -+ -+#define MAKE_OP(OPNAME, SUFF, OPKIND, STORE) \ -+static void OPNAME ## _pixels ## SUFF ## _axp \ -+ (uint8_t *restrict block, const uint8_t *restrict pixels, \ -+ int line_size, int h) \ -+{ \ -+ if ((size_t) pixels & 0x7) { \ -+ OPKIND(uldq, STORE); \ -+ } else { \ -+ OPKIND(ldq, STORE); \ -+ } \ -+} \ -+ \ -+static void OPNAME ## _pixels16 ## SUFF ## _axp \ -+ (uint8_t *restrict block, const uint8_t *restrict pixels, \ -+ int line_size, int h) \ -+{ \ -+ OPNAME ## _pixels ## SUFF ## _axp(block, pixels, line_size, h); \ -+ OPNAME ## _pixels ## SUFF ## _axp(block + 8, pixels + 8, line_size, h); \ -+} -+ -+#define PIXOP(OPNAME, STORE) \ -+ MAKE_OP(OPNAME, , OP, STORE) \ -+ MAKE_OP(OPNAME, _x2, OP_X2, STORE) \ -+ MAKE_OP(OPNAME, _y2, OP_Y2, STORE) \ -+ MAKE_OP(OPNAME, _xy2, OP_XY2, STORE) -+ -+/* Rounding primitives. */ -+#define AVG2 avg2 -+#define AVG4 avg4 -+#define AVG4_ROUNDER BYTE_VEC(0x02) -+#define STORE(l, b) stq(l, b) -+PIXOP(put, STORE); -+ -+#undef STORE -+#define STORE(l, b) stq(AVG2(l, ldq(b)), b); -+PIXOP(avg, STORE); -+ -+/* Not rounding primitives. */ -+#undef AVG2 -+#undef AVG4 -+#undef AVG4_ROUNDER -+#undef STORE -+#define AVG2 avg2_no_rnd -+#define AVG4 avg4_no_rnd -+#define AVG4_ROUNDER BYTE_VEC(0x01) -+#define STORE(l, b) stq(l, b) -+PIXOP(put_no_rnd, STORE); -+ -+#undef STORE -+#define STORE(l, b) stq(AVG2(l, ldq(b)), b); -+PIXOP(avg_no_rnd, STORE); -+ -+void put_pixels16_axp_asm(uint8_t *block, const uint8_t *pixels, -+ int line_size, int h) -+{ -+ put_pixels_axp_asm(block, pixels, line_size, h); -+ put_pixels_axp_asm(block + 8, pixels + 8, line_size, h); -+} -+ -+static int sad16x16_mvi(void *s, uint8_t *a, uint8_t *b, int stride) -+{ -+ return pix_abs16x16_mvi_asm(a, b, stride); -+} -+ -+static int sad8x8_mvi(void *s, uint8_t *a, uint8_t *b, int stride) -+{ -+ return pix_abs8x8_mvi(a, b, stride); -+} -+ -+void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx) -+{ -+ c->put_pixels_tab[0][0] = put_pixels16_axp_asm; -+ c->put_pixels_tab[0][1] = put_pixels16_x2_axp; -+ c->put_pixels_tab[0][2] = put_pixels16_y2_axp; -+ c->put_pixels_tab[0][3] = put_pixels16_xy2_axp; -+ -+ c->put_no_rnd_pixels_tab[0][0] = put_pixels16_axp_asm; -+ c->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_axp; -+ c->put_no_rnd_pixels_tab[0][2] = put_no_rnd_pixels16_y2_axp; -+ c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_axp; -+ -+ c->avg_pixels_tab[0][0] = avg_pixels16_axp; -+ c->avg_pixels_tab[0][1] = avg_pixels16_x2_axp; -+ c->avg_pixels_tab[0][2] = avg_pixels16_y2_axp; -+ c->avg_pixels_tab[0][3] = avg_pixels16_xy2_axp; -+ -+ c->avg_no_rnd_pixels_tab[0][0] = avg_no_rnd_pixels16_axp; -+ c->avg_no_rnd_pixels_tab[0][1] = avg_no_rnd_pixels16_x2_axp; -+ c->avg_no_rnd_pixels_tab[0][2] = avg_no_rnd_pixels16_y2_axp; -+ c->avg_no_rnd_pixels_tab[0][3] = avg_no_rnd_pixels16_xy2_axp; -+ -+ c->put_pixels_tab[1][0] = put_pixels_axp_asm; -+ c->put_pixels_tab[1][1] = put_pixels_x2_axp; -+ c->put_pixels_tab[1][2] = put_pixels_y2_axp; -+ c->put_pixels_tab[1][3] = put_pixels_xy2_axp; -+ -+ c->put_no_rnd_pixels_tab[1][0] = put_pixels_axp_asm; -+ c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels_x2_axp; -+ c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels_y2_axp; -+ c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels_xy2_axp; -+ -+ c->avg_pixels_tab[1][0] = avg_pixels_axp; -+ c->avg_pixels_tab[1][1] = avg_pixels_x2_axp; -+ c->avg_pixels_tab[1][2] = avg_pixels_y2_axp; -+ c->avg_pixels_tab[1][3] = avg_pixels_xy2_axp; -+ -+ c->avg_no_rnd_pixels_tab[1][0] = avg_no_rnd_pixels_axp; -+ c->avg_no_rnd_pixels_tab[1][1] = avg_no_rnd_pixels_x2_axp; -+ c->avg_no_rnd_pixels_tab[1][2] = avg_no_rnd_pixels_y2_axp; -+ c->avg_no_rnd_pixels_tab[1][3] = avg_no_rnd_pixels_xy2_axp; -+ -+ c->clear_blocks = clear_blocks_axp; -+ -+ /* amask clears all bits that correspond to present features. */ -+ if (amask(AMASK_MVI) == 0) { -+ c->put_pixels_clamped = put_pixels_clamped_mvi_asm; -+ c->add_pixels_clamped = add_pixels_clamped_mvi_asm; -+ -+ c->get_pixels = get_pixels_mvi; -+ c->diff_pixels = diff_pixels_mvi; -+ c->sad[0] = sad16x16_mvi; -+ c->sad[1] = sad8x8_mvi; -+ c->pix_abs8x8 = pix_abs8x8_mvi; -+ c->pix_abs16x16 = pix_abs16x16_mvi_asm; -+ c->pix_abs16x16_x2 = pix_abs16x16_x2_mvi; -+ c->pix_abs16x16_y2 = pix_abs16x16_y2_mvi; -+ c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mvi; -+ } -+ -+ put_pixels_clamped_axp_p = c->put_pixels_clamped; -+ add_pixels_clamped_axp_p = c->add_pixels_clamped; -+ -+ c->idct_put = simple_idct_put_axp; -+ c->idct_add = simple_idct_add_axp; -+ c->idct = simple_idct_axp; -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/Makefile.am avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/Makefile.am ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/Makefile.am 2003-05-25 23:07:42.000000000 +0200 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/Makefile.am 2003-11-13 23:51:25.426454176 +0100 -@@ -7,10 +7,12 @@ +--- avifile-0.7-0.7.41/ffmpeg/libavcodec/alpha/Makefile.am.orig 2004-03-09 12:24:34.000000000 +0100 ++++ avifile-0.7-0.7.41/ffmpeg/libavcodec/alpha/Makefile.am 2004-12-05 01:36:57.171071648 +0100 +@@ -6,12 +6,12 @@ dsputil_alpha.c \ motion_est_alpha.c \ mpegvideo_alpha.c \ @@ -510,779 +8,14 @@ diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/Makefile.am avifile-0. + simple_idct_alpha.c \ + dsputil_alpha_asm.S \ + motion_est_mvi_asm.S - endif - --noinst_HEADERS = asm.h dsputil_alpha_asm.S regdef.h motion_est_mvi_asm.S -+noinst_HEADERS = asm.h regdef.h - - libavcodecalpha_la_SOURCES = $(ALPHA_SRC) - -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/motion_est_alpha.c avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/motion_est_alpha.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/motion_est_alpha.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/motion_est_alpha.c 2003-09-28 17:26:39.000000000 +0200 -@@ -0,0 +1,347 @@ -+/* -+ * Alpha optimized DSP utils -+ * Copyright (c) 2002 Falk Hueffner -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "asm.h" -+#include "../dsputil.h" -+ -+void get_pixels_mvi(DCTELEM *restrict block, -+ const uint8_t *restrict pixels, int line_size) -+{ -+ int h = 8; -+ -+ do { -+ uint64_t p; -+ -+ p = ldq(pixels); -+ stq(unpkbw(p), block); -+ stq(unpkbw(p >> 32), block + 4); -+ -+ pixels += line_size; -+ block += 8; -+ } while (--h); -+} -+ -+void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, -+ int stride) { -+ int h = 8; -+ uint64_t mask = 0x4040; -+ -+ mask |= mask << 16; -+ mask |= mask << 32; -+ do { -+ uint64_t x, y, c, d, a; -+ uint64_t signs; -+ -+ x = ldq(s1); -+ y = ldq(s2); -+ c = cmpbge(x, y); -+ d = x - y; -+ a = zap(mask, c); /* We use 0x4040404040404040 here... */ -+ d += 4 * a; /* ...so we can use s4addq here. */ -+ signs = zap(-1, c); -+ -+ stq(unpkbw(d) | (unpkbw(signs) << 8), block); -+ stq(unpkbw(d >> 32) | (unpkbw(signs >> 32) << 8), block + 4); -+ -+ s1 += stride; -+ s2 += stride; -+ block += 8; -+ } while (--h); -+} -+ -+static inline uint64_t avg2(uint64_t a, uint64_t b) -+{ -+ return (a | b) - (((a ^ b) & BYTE_VEC(0xfe)) >> 1); -+} -+ -+static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4) -+{ -+ uint64_t r1 = ((l1 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l2 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l3 & ~BYTE_VEC(0x03)) >> 2) -+ + ((l4 & ~BYTE_VEC(0x03)) >> 2); -+ uint64_t r2 = (( (l1 & BYTE_VEC(0x03)) -+ + (l2 & BYTE_VEC(0x03)) -+ + (l3 & BYTE_VEC(0x03)) -+ + (l4 & BYTE_VEC(0x03)) -+ + BYTE_VEC(0x02)) >> 2) & BYTE_VEC(0x03); -+ return r1 + r2; -+} -+ -+int pix_abs8x8_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int result = 0; -+ int h = 8; -+ -+ if ((size_t) pix2 & 0x7) { -+ /* works only when pix2 is actually unaligned */ -+ do { /* do 8 pixel a time */ -+ uint64_t p1, p2; -+ -+ p1 = ldq(pix1); -+ p2 = uldq(pix2); -+ result += perr(p1, p2); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } while (--h); -+ } else { -+ do { -+ uint64_t p1, p2; -+ -+ p1 = ldq(pix1); -+ p2 = ldq(pix2); -+ result += perr(p1, p2); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } while (--h); -+ } -+ -+ return result; -+} -+ -+#if 0 /* now done in assembly */ -+int pix_abs16x16_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int result = 0; -+ int h = 16; -+ -+ if ((size_t) pix2 & 0x7) { -+ /* works only when pix2 is actually unaligned */ -+ do { /* do 16 pixel a time */ -+ uint64_t p1_l, p1_r, p2_l, p2_r; -+ uint64_t t; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ t = ldq_u(pix2 + 8); -+ p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); -+ p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ result += perr(p1_l, p2_l) -+ + perr(p1_r, p2_r); -+ } while (--h); -+ } else { -+ do { -+ uint64_t p1_l, p1_r, p2_l, p2_r; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ p2_l = ldq(pix2); -+ p2_r = ldq(pix2 + 8); -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ result += perr(p1_l, p2_l) -+ + perr(p1_r, p2_r); -+ } while (--h); -+ } -+ -+ return result; -+} -+#endif -+ -+int pix_abs16x16_x2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int result = 0; -+ int h = 16; -+ uint64_t disalign = (size_t) pix2 & 0x7; -+ -+ switch (disalign) { -+ case 0: -+ do { -+ uint64_t p1_l, p1_r, p2_l, p2_r; -+ uint64_t l, r; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ l = ldq(pix2); -+ r = ldq(pix2 + 8); -+ p2_l = avg2(l, (l >> 8) | ((uint64_t) r << 56)); -+ p2_r = avg2(r, (r >> 8) | ((uint64_t) pix2[16] << 56)); -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ result += perr(p1_l, p2_l) -+ + perr(p1_r, p2_r); -+ } while (--h); -+ break; -+ case 7: -+ /* |.......l|lllllllr|rrrrrrr*| -+ This case is special because disalign1 would be 8, which -+ gets treated as 0 by extqh. At least it is a bit faster -+ that way :) */ -+ do { -+ uint64_t p1_l, p1_r, p2_l, p2_r; -+ uint64_t l, m, r; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ l = ldq_u(pix2); -+ m = ldq_u(pix2 + 8); -+ r = ldq_u(pix2 + 16); -+ p2_l = avg2(extql(l, disalign) | extqh(m, disalign), m); -+ p2_r = avg2(extql(m, disalign) | extqh(r, disalign), r); -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ result += perr(p1_l, p2_l) -+ + perr(p1_r, p2_r); -+ } while (--h); -+ break; -+ default: -+ do { -+ uint64_t disalign1 = disalign + 1; -+ uint64_t p1_l, p1_r, p2_l, p2_r; -+ uint64_t l, m, r; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ l = ldq_u(pix2); -+ m = ldq_u(pix2 + 8); -+ r = ldq_u(pix2 + 16); -+ p2_l = avg2(extql(l, disalign) | extqh(m, disalign), -+ extql(l, disalign1) | extqh(m, disalign1)); -+ p2_r = avg2(extql(m, disalign) | extqh(r, disalign), -+ extql(m, disalign1) | extqh(r, disalign1)); -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ result += perr(p1_l, p2_l) -+ + perr(p1_r, p2_r); -+ } while (--h); -+ break; -+ } -+ return result; -+} -+ -+int pix_abs16x16_y2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int result = 0; -+ int h = 16; -+ -+ if ((size_t) pix2 & 0x7) { -+ uint64_t t, p2_l, p2_r; -+ t = ldq_u(pix2 + 8); -+ p2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); -+ p2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); -+ -+ do { -+ uint64_t p1_l, p1_r, np2_l, np2_r; -+ uint64_t t; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ pix2 += line_size; -+ t = ldq_u(pix2 + 8); -+ np2_l = extql(ldq_u(pix2), pix2) | extqh(t, pix2); -+ np2_r = extql(t, pix2) | extqh(ldq_u(pix2 + 16), pix2); -+ -+ result += perr(p1_l, avg2(p2_l, np2_l)) -+ + perr(p1_r, avg2(p2_r, np2_r)); -+ -+ pix1 += line_size; -+ p2_l = np2_l; -+ p2_r = np2_r; -+ -+ } while (--h); -+ } else { -+ uint64_t p2_l, p2_r; -+ p2_l = ldq(pix2); -+ p2_r = ldq(pix2 + 8); -+ do { -+ uint64_t p1_l, p1_r, np2_l, np2_r; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ pix2 += line_size; -+ np2_l = ldq(pix2); -+ np2_r = ldq(pix2 + 8); -+ -+ result += perr(p1_l, avg2(p2_l, np2_l)) -+ + perr(p1_r, avg2(p2_r, np2_r)); -+ -+ pix1 += line_size; -+ p2_l = np2_l; -+ p2_r = np2_r; -+ } while (--h); -+ } -+ return result; -+} -+ -+int pix_abs16x16_xy2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int result = 0; -+ int h = 16; -+ -+ uint64_t p1_l, p1_r; -+ uint64_t p2_l, p2_r, p2_x; -+ -+ p1_l = ldq(pix1); -+ p1_r = ldq(pix1 + 8); -+ -+ if ((size_t) pix2 & 0x7) { /* could be optimized a lot */ -+ p2_l = uldq(pix2); -+ p2_r = uldq(pix2 + 8); -+ p2_x = (uint64_t) pix2[16] << 56; -+ } else { -+ p2_l = ldq(pix2); -+ p2_r = ldq(pix2 + 8); -+ p2_x = ldq(pix2 + 16) << 56; -+ } -+ -+ do { -+ uint64_t np1_l, np1_r; -+ uint64_t np2_l, np2_r, np2_x; -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ -+ np1_l = ldq(pix1); -+ np1_r = ldq(pix1 + 8); -+ -+ if ((size_t) pix2 & 0x7) { /* could be optimized a lot */ -+ np2_l = uldq(pix2); -+ np2_r = uldq(pix2 + 8); -+ np2_x = (uint64_t) pix2[16] << 56; -+ } else { -+ np2_l = ldq(pix2); -+ np2_r = ldq(pix2 + 8); -+ np2_x = ldq(pix2 + 16) << 56; -+ } -+ -+ result += perr(p1_l, -+ avg4( p2_l, ( p2_l >> 8) | ((uint64_t) p2_r << 56), -+ np2_l, (np2_l >> 8) | ((uint64_t) np2_r << 56))) -+ + perr(p1_r, -+ avg4( p2_r, ( p2_r >> 8) | ((uint64_t) p2_x), -+ np2_r, (np2_r >> 8) | ((uint64_t) np2_x))); -+ -+ p1_l = np1_l; -+ p1_r = np1_r; -+ p2_l = np2_l; -+ p2_r = np2_r; -+ p2_x = np2_x; -+ } while (--h); -+ -+ return result; -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/mpegvideo_alpha.c avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/mpegvideo_alpha.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/mpegvideo_alpha.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/mpegvideo_alpha.c 2003-09-28 17:26:39.000000000 +0200 -@@ -0,0 +1,96 @@ -+/* -+ * Alpha optimized DSP utils -+ * Copyright (c) 2002 Falk Hueffner -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "asm.h" -+#include "../dsputil.h" -+#include "../mpegvideo.h" -+ -+static void dct_unquantize_h263_axp(MpegEncContext *s, DCTELEM *block, -+ int n, int qscale) -+{ -+ int i, n_coeffs; -+ uint64_t qmul, qadd; -+ uint64_t correction; -+ DCTELEM *orig_block = block; -+ DCTELEM block0; -+ -+ qadd = WORD_VEC((qscale - 1) | 1); -+ qmul = qscale << 1; -+ /* This mask kills spill from negative subwords to the next subword. */ -+ correction = WORD_VEC((qmul - 1) + 1); /* multiplication / addition */ -+ -+ if (s->mb_intra) { -+ if (!s->h263_aic) { -+ if (n < 4) -+ block0 = block[0] * s->y_dc_scale; -+ else -+ block0 = block[0] * s->c_dc_scale; -+ } else { -+ qadd = 0; -+ } -+ n_coeffs = 63; // does not always use zigzag table -+ } else { -+ n_coeffs = s->intra_scantable.raster_end[s->block_last_index[n]]; -+ } -+ -+ for(i = 0; i <= n_coeffs; block += 4, i += 4) { -+ uint64_t levels, negmask, zeros, add; -+ -+ levels = ldq(block); -+ if (levels == 0) -+ continue; -+ -+#ifdef __alpha_max__ -+ /* I don't think the speed difference justifies runtime -+ detection. */ -+ negmask = maxsw4(levels, -1); /* negative -> ffff (-1) */ -+ negmask = minsw4(negmask, 0); /* positive -> 0000 (0) */ -+#else -+ negmask = cmpbge(WORD_VEC(0x7fff), levels); -+ negmask &= (negmask >> 1) | (1 << 7); -+ negmask = zap(-1, negmask); -+#endif -+ -+ zeros = cmpbge(0, levels); -+ zeros &= zeros >> 1; -+ /* zeros |= zeros << 1 is not needed since qadd <= 255, so -+ zapping the lower byte suffices. */ -+ -+ levels *= qmul; -+ levels -= correction & (negmask << 16); -+ -+ /* Negate qadd for negative levels. */ -+ add = qadd ^ negmask; -+ add += WORD_VEC(0x0001) & negmask; -+ /* Set qadd to 0 for levels == 0. */ -+ add = zap(add, zeros); -+ -+ levels += add; -+ -+ stq(levels, block); -+ } -+ -+ if (s->mb_intra && !s->h263_aic) -+ orig_block[0] = block0; -+} -+ -+void MPV_common_init_axp(MpegEncContext *s) -+{ -+ s->dct_unquantize_h263 = dct_unquantize_h263_axp; -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/simple_idct_alpha.c avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/simple_idct_alpha.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha.orig/simple_idct_alpha.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/alpha/simple_idct_alpha.c 2003-09-28 17:26:39.000000000 +0200 -@@ -0,0 +1,311 @@ -+/* -+ * Simple IDCT (Alpha optimized) -+ * -+ * Copyright (c) 2001 Michael Niedermayer -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ * -+ * based upon some outcommented c code from mpeg2dec (idct_mmx.c -+ * written by Aaron Holtzman ) -+ * -+ * Alpha optimiziations by Måns Rullgård -+ * and Falk Hueffner -+ */ -+ -+#include "asm.h" -+#include "../dsputil.h" -+ -+extern void (*put_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+extern void (*add_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels, -+ int line_size); -+ -+// cos(i * M_PI / 16) * sqrt(2) * (1 << 14) -+// W4 is actually exactly 16384, but using 16383 works around -+// accumulating rounding errors for some encoders -+#define W1 ((int_fast32_t) 22725) -+#define W2 ((int_fast32_t) 21407) -+#define W3 ((int_fast32_t) 19266) -+#define W4 ((int_fast32_t) 16383) -+#define W5 ((int_fast32_t) 12873) -+#define W6 ((int_fast32_t) 8867) -+#define W7 ((int_fast32_t) 4520) -+#define ROW_SHIFT 11 -+#define COL_SHIFT 20 -+ -+/* 0: all entries 0, 1: only first entry nonzero, 2: otherwise */ -+static inline int idct_row(DCTELEM *row) -+{ -+ int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3, t; -+ uint64_t l, r, t2; -+ l = ldq(row); -+ r = ldq(row + 4); -+ -+ if (l == 0 && r == 0) -+ return 0; -+ -+ a0 = W4 * sextw(l) + (1 << (ROW_SHIFT - 1)); -+ -+ if (((l & ~0xffffUL) | r) == 0) { -+ a0 >>= ROW_SHIFT; -+ t2 = (uint16_t) a0; -+ t2 |= t2 << 16; -+ t2 |= t2 << 32; -+ -+ stq(t2, row); -+ stq(t2, row + 4); -+ return 1; -+ } -+ -+ a1 = a0; -+ a2 = a0; -+ a3 = a0; -+ -+ t = extwl(l, 4); /* row[2] */ -+ if (t != 0) { -+ t = sextw(t); -+ a0 += W2 * t; -+ a1 += W6 * t; -+ a2 -= W6 * t; -+ a3 -= W2 * t; -+ } -+ -+ t = extwl(r, 0); /* row[4] */ -+ if (t != 0) { -+ t = sextw(t); -+ a0 += W4 * t; -+ a1 -= W4 * t; -+ a2 -= W4 * t; -+ a3 += W4 * t; -+ } -+ -+ t = extwl(r, 4); /* row[6] */ -+ if (t != 0) { -+ t = sextw(t); -+ a0 += W6 * t; -+ a1 -= W2 * t; -+ a2 += W2 * t; -+ a3 -= W6 * t; -+ } -+ -+ t = extwl(l, 2); /* row[1] */ -+ if (t != 0) { -+ t = sextw(t); -+ b0 = W1 * t; -+ b1 = W3 * t; -+ b2 = W5 * t; -+ b3 = W7 * t; -+ } else { -+ b0 = 0; -+ b1 = 0; -+ b2 = 0; -+ b3 = 0; -+ } -+ -+ t = extwl(l, 6); /* row[3] */ -+ if (t) { -+ t = sextw(t); -+ b0 += W3 * t; -+ b1 -= W7 * t; -+ b2 -= W1 * t; -+ b3 -= W5 * t; -+ } -+ -+ -+ t = extwl(r, 2); /* row[5] */ -+ if (t) { -+ t = sextw(t); -+ b0 += W5 * t; -+ b1 -= W1 * t; -+ b2 += W7 * t; -+ b3 += W3 * t; -+ } -+ -+ t = extwl(r, 6); /* row[7] */ -+ if (t) { -+ t = sextw(t); -+ b0 += W7 * t; -+ b1 -= W5 * t; -+ b2 += W3 * t; -+ b3 -= W1 * t; -+ } -+ -+ row[0] = (a0 + b0) >> ROW_SHIFT; -+ row[1] = (a1 + b1) >> ROW_SHIFT; -+ row[2] = (a2 + b2) >> ROW_SHIFT; -+ row[3] = (a3 + b3) >> ROW_SHIFT; -+ row[4] = (a3 - b3) >> ROW_SHIFT; -+ row[5] = (a2 - b2) >> ROW_SHIFT; -+ row[6] = (a1 - b1) >> ROW_SHIFT; -+ row[7] = (a0 - b0) >> ROW_SHIFT; -+ -+ return 2; -+} -+ -+static inline void idct_col(DCTELEM *col) -+{ -+ int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3; -+ -+ col[0] += (1 << (COL_SHIFT - 1)) / W4; -+ -+ a0 = W4 * col[8 * 0]; -+ a1 = W4 * col[8 * 0]; -+ a2 = W4 * col[8 * 0]; -+ a3 = W4 * col[8 * 0]; -+ -+ if (col[8 * 2]) { -+ a0 += W2 * col[8 * 2]; -+ a1 += W6 * col[8 * 2]; -+ a2 -= W6 * col[8 * 2]; -+ a3 -= W2 * col[8 * 2]; -+ } -+ -+ if (col[8 * 4]) { -+ a0 += W4 * col[8 * 4]; -+ a1 -= W4 * col[8 * 4]; -+ a2 -= W4 * col[8 * 4]; -+ a3 += W4 * col[8 * 4]; -+ } -+ -+ if (col[8 * 6]) { -+ a0 += W6 * col[8 * 6]; -+ a1 -= W2 * col[8 * 6]; -+ a2 += W2 * col[8 * 6]; -+ a3 -= W6 * col[8 * 6]; -+ } -+ -+ if (col[8 * 1]) { -+ b0 = W1 * col[8 * 1]; -+ b1 = W3 * col[8 * 1]; -+ b2 = W5 * col[8 * 1]; -+ b3 = W7 * col[8 * 1]; -+ } else { -+ b0 = 0; -+ b1 = 0; -+ b2 = 0; -+ b3 = 0; -+ } -+ -+ if (col[8 * 3]) { -+ b0 += W3 * col[8 * 3]; -+ b1 -= W7 * col[8 * 3]; -+ b2 -= W1 * col[8 * 3]; -+ b3 -= W5 * col[8 * 3]; -+ } -+ -+ if (col[8 * 5]) { -+ b0 += W5 * col[8 * 5]; -+ b1 -= W1 * col[8 * 5]; -+ b2 += W7 * col[8 * 5]; -+ b3 += W3 * col[8 * 5]; -+ } -+ -+ if (col[8 * 7]) { -+ b0 += W7 * col[8 * 7]; -+ b1 -= W5 * col[8 * 7]; -+ b2 += W3 * col[8 * 7]; -+ b3 -= W1 * col[8 * 7]; -+ } -+ -+ col[8 * 0] = (a0 + b0) >> COL_SHIFT; -+ col[8 * 7] = (a0 - b0) >> COL_SHIFT; -+ col[8 * 1] = (a1 + b1) >> COL_SHIFT; -+ col[8 * 6] = (a1 - b1) >> COL_SHIFT; -+ col[8 * 2] = (a2 + b2) >> COL_SHIFT; -+ col[8 * 5] = (a2 - b2) >> COL_SHIFT; -+ col[8 * 3] = (a3 + b3) >> COL_SHIFT; -+ col[8 * 4] = (a3 - b3) >> COL_SHIFT; -+} -+ -+/* If all rows but the first one are zero after row transformation, -+ all rows will be identical after column transformation. */ -+static inline void idct_col2(DCTELEM *col) -+{ -+ int i; -+ uint64_t l, r; -+ uint64_t *lcol = (uint64_t *) col; -+ -+ for (i = 0; i < 8; ++i) { -+ int_fast32_t a0 = col[0] + (1 << (COL_SHIFT - 1)) / W4; -+ -+ a0 *= W4; -+ col[0] = a0 >> COL_SHIFT; -+ ++col; -+ } -+ -+ l = lcol[0]; -+ r = lcol[1]; -+ lcol[ 2] = l; lcol[ 3] = r; -+ lcol[ 4] = l; lcol[ 5] = r; -+ lcol[ 6] = l; lcol[ 7] = r; -+ lcol[ 8] = l; lcol[ 9] = r; -+ lcol[10] = l; lcol[11] = r; -+ lcol[12] = l; lcol[13] = r; -+ lcol[14] = l; lcol[15] = r; -+} -+ -+void simple_idct_axp(DCTELEM *block) -+{ -+ -+ int i; -+ int rowsZero = 1; /* all rows except row 0 zero */ -+ int rowsConstant = 1; /* all rows consist of a constant value */ -+ -+ for (i = 0; i < 8; i++) { -+ int sparseness = idct_row(block + 8 * i); -+ -+ if (i > 0 && sparseness > 0) -+ rowsZero = 0; -+ if (sparseness == 2) -+ rowsConstant = 0; -+ } -+ -+ if (rowsZero) { -+ idct_col2(block); -+ } else if (rowsConstant) { -+ uint64_t *lblock = (uint64_t *) block; -+ -+ idct_col(block); -+ for (i = 0; i < 8; i += 2) { -+ uint64_t v = (uint16_t) block[i * 8]; -+ uint64_t w = (uint16_t) block[i * 8 + 8]; -+ -+ v |= v << 16; -+ w |= w << 16; -+ v |= v << 32; -+ w |= w << 32; -+ lblock[0] = v; -+ lblock[1] = v; -+ lblock[2] = w; -+ lblock[3] = w; -+ lblock += 4; -+ } -+ } else { -+ for (i = 0; i < 8; i++) -+ idct_col(block + i); -+ } -+} -+ -+void simple_idct_put_axp(uint8_t *dest, int line_size, DCTELEM *block) -+{ -+ simple_idct_axp(block); -+ put_pixels_clamped_axp_p(block, dest, line_size); -+} -+ -+void simple_idct_add_axp(uint8_t *dest, int line_size, DCTELEM *block) -+{ -+ simple_idct_axp(block); -+ add_pixels_clamped_axp_p(block, dest, line_size); -+} + + noinst_HEADERS = $(ALPHA_SOURCES) \ + asm.h \ +- dsputil_alpha_asm.S \ +- motion_est_mvi_asm.S \ + regdef.h + + if AMM_FF_ALPHAOPT --- avifile-0.7-0.7.38/configure.in.orig 2003-07-10 13:15:54.000000000 +0200 +++ avifile-0.7-0.7.38/configure.in 2003-11-14 00:09:16.019699264 +0100 @@ -57,6 +57,7 @@ diff --git a/avifile-ffmpeg-ppc.patch b/avifile-ffmpeg-ppc.patch index f74d33e..f9af30a 100644 --- a/avifile-ffmpeg-ppc.patch +++ b/avifile-ffmpeg-ppc.patch @@ -1,3143 +1,3 @@ -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/dsputil_altivec.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/dsputil_altivec.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/dsputil_altivec.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/dsputil_altivec.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,1345 @@ -+/* -+ * Copyright (c) 2002 Brian Foley -+ * Copyright (c) 2002 Dieter Shirley -+ * Copyright (c) 2003 Romain Dolbeau -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "../dsputil.h" -+ -+#include "gcc_fixes.h" -+ -+#include "dsputil_altivec.h" -+ -+#ifdef CONFIG_DARWIN -+#include -+#else /* CONFIG_DARWIN */ -+#include -+#include -+ -+static sigjmp_buf jmpbuf; -+static volatile sig_atomic_t canjump = 0; -+ -+static void sigill_handler (int sig) -+{ -+ if (!canjump) { -+ signal (sig, SIG_DFL); -+ raise (sig); -+ } -+ -+ canjump = 0; -+ siglongjmp (jmpbuf, 1); -+} -+#endif /* CONFIG_DARWIN */ -+ -+int pix_abs16x16_x2_altivec(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0); -+ vector unsigned char *tv; -+ vector unsigned char pix1v, pix2v, pix2iv, avgv, t5; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ -+ s = 0; -+ sad = (vector unsigned int)vec_splat_u32(0); -+ for(i=0;i<16;i++) { -+ /* -+ Read unaligned pixels into our vectors. The vectors are as follows: -+ pix1v: pix1[0]-pix1[15] -+ pix2v: pix2[0]-pix2[15] pix2iv: pix2[1]-pix2[16] -+ */ -+ tv = (vector unsigned char *) pix1; -+ pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1)); -+ -+ tv = (vector unsigned char *) &pix2[0]; -+ pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0])); -+ -+ tv = (vector unsigned char *) &pix2[1]; -+ pix2iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[1])); -+ -+ /* Calculate the average vector */ -+ avgv = vec_avg(pix2v, pix2iv); -+ -+ /* Calculate a sum of abs differences vector */ -+ t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv)); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t5, sad); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ -+ return s; -+} -+ -+int pix_abs16x16_y2_altivec(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0); -+ vector unsigned char *tv; -+ vector unsigned char pix1v, pix2v, pix3v, avgv, t5; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ uint8_t *pix3 = pix2 + line_size; -+ -+ s = 0; -+ sad = (vector unsigned int)vec_splat_u32(0); -+ -+ /* -+ Due to the fact that pix3 = pix2 + line_size, the pix3 of one -+ iteration becomes pix2 in the next iteration. We can use this -+ fact to avoid a potentially expensive unaligned read, each -+ time around the loop. -+ Read unaligned pixels into our vectors. The vectors are as follows: -+ pix2v: pix2[0]-pix2[15] -+ Split the pixel vectors into shorts -+ */ -+ tv = (vector unsigned char *) &pix2[0]; -+ pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0])); -+ -+ for(i=0;i<16;i++) { -+ /* -+ Read unaligned pixels into our vectors. The vectors are as follows: -+ pix1v: pix1[0]-pix1[15] -+ pix3v: pix3[0]-pix3[15] -+ */ -+ tv = (vector unsigned char *) pix1; -+ pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1)); -+ -+ tv = (vector unsigned char *) &pix3[0]; -+ pix3v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[0])); -+ -+ /* Calculate the average vector */ -+ avgv = vec_avg(pix2v, pix3v); -+ -+ /* Calculate a sum of abs differences vector */ -+ t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv)); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t5, sad); -+ -+ pix1 += line_size; -+ pix2v = pix3v; -+ pix3 += line_size; -+ -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ return s; -+} -+ -+int pix_abs16x16_xy2_altivec(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ uint8_t *pix3 = pix2 + line_size; -+ const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0); -+ const vector unsigned short two = (const vector unsigned short)vec_splat_u16(2); -+ vector unsigned char *tv, avgv, t5; -+ vector unsigned char pix1v, pix2v, pix3v, pix2iv, pix3iv; -+ vector unsigned short pix2lv, pix2hv, pix2ilv, pix2ihv; -+ vector unsigned short pix3lv, pix3hv, pix3ilv, pix3ihv; -+ vector unsigned short avghv, avglv; -+ vector unsigned short t1, t2, t3, t4; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ -+ sad = (vector unsigned int)vec_splat_u32(0); -+ -+ s = 0; -+ -+ /* -+ Due to the fact that pix3 = pix2 + line_size, the pix3 of one -+ iteration becomes pix2 in the next iteration. We can use this -+ fact to avoid a potentially expensive unaligned read, as well -+ as some splitting, and vector addition each time around the loop. -+ Read unaligned pixels into our vectors. The vectors are as follows: -+ pix2v: pix2[0]-pix2[15] pix2iv: pix2[1]-pix2[16] -+ Split the pixel vectors into shorts -+ */ -+ tv = (vector unsigned char *) &pix2[0]; -+ pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0])); -+ -+ tv = (vector unsigned char *) &pix2[1]; -+ pix2iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[1])); -+ -+ pix2hv = (vector unsigned short) vec_mergeh(zero, pix2v); -+ pix2lv = (vector unsigned short) vec_mergel(zero, pix2v); -+ pix2ihv = (vector unsigned short) vec_mergeh(zero, pix2iv); -+ pix2ilv = (vector unsigned short) vec_mergel(zero, pix2iv); -+ t1 = vec_add(pix2hv, pix2ihv); -+ t2 = vec_add(pix2lv, pix2ilv); -+ -+ for(i=0;i<16;i++) { -+ /* -+ Read unaligned pixels into our vectors. The vectors are as follows: -+ pix1v: pix1[0]-pix1[15] -+ pix3v: pix3[0]-pix3[15] pix3iv: pix3[1]-pix3[16] -+ */ -+ tv = (vector unsigned char *) pix1; -+ pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1)); -+ -+ tv = (vector unsigned char *) &pix3[0]; -+ pix3v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[0])); -+ -+ tv = (vector unsigned char *) &pix3[1]; -+ pix3iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[1])); -+ -+ /* -+ Note that Altivec does have vec_avg, but this works on vector pairs -+ and rounds up. We could do avg(avg(a,b),avg(c,d)), but the rounding -+ would mean that, for example, avg(3,0,0,1) = 2, when it should be 1. -+ Instead, we have to split the pixel vectors into vectors of shorts, -+ and do the averaging by hand. -+ */ -+ -+ /* Split the pixel vectors into shorts */ -+ pix3hv = (vector unsigned short) vec_mergeh(zero, pix3v); -+ pix3lv = (vector unsigned short) vec_mergel(zero, pix3v); -+ pix3ihv = (vector unsigned short) vec_mergeh(zero, pix3iv); -+ pix3ilv = (vector unsigned short) vec_mergel(zero, pix3iv); -+ -+ /* Do the averaging on them */ -+ t3 = vec_add(pix3hv, pix3ihv); -+ t4 = vec_add(pix3lv, pix3ilv); -+ -+ avghv = vec_sr(vec_add(vec_add(t1, t3), two), two); -+ avglv = vec_sr(vec_add(vec_add(t2, t4), two), two); -+ -+ /* Pack the shorts back into a result */ -+ avgv = vec_pack(avghv, avglv); -+ -+ /* Calculate a sum of abs differences vector */ -+ t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv)); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t5, sad); -+ -+ pix1 += line_size; -+ pix3 += line_size; -+ /* Transfer the calculated values for pix3 into pix2 */ -+ t1 = t3; -+ t2 = t4; -+ } -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ -+ return s; -+} -+ -+int pix_abs16x16_altivec(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char perm1, perm2, *pix1v, *pix2v; -+ vector unsigned char t1, t2, t3,t4, t5; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ -+ sad = (vector unsigned int)vec_splat_u32(0); -+ -+ -+ for(i=0;i<16;i++) { -+ /* Read potentially unaligned pixels into t1 and t2 */ -+ perm1 = vec_lvsl(0, pix1); -+ pix1v = (vector unsigned char *) pix1; -+ perm2 = vec_lvsl(0, pix2); -+ pix2v = (vector unsigned char *) pix2; -+ t1 = vec_perm(pix1v[0], pix1v[1], perm1); -+ t2 = vec_perm(pix2v[0], pix2v[1], perm2); -+ -+ /* Calculate a sum of abs differences vector */ -+ t3 = vec_max(t1, t2); -+ t4 = vec_min(t1, t2); -+ t5 = vec_sub(t3, t4); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t5, sad); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ -+ return s; -+} -+ -+int pix_abs8x8_altivec(uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char perm1, perm2, permclear, *pix1v, *pix2v; -+ vector unsigned char t1, t2, t3,t4, t5; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ -+ sad = (vector unsigned int)vec_splat_u32(0); -+ -+ permclear = (vector unsigned char)AVV(255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0); -+ -+ for(i=0;i<8;i++) { -+ /* Read potentially unaligned pixels into t1 and t2 -+ Since we're reading 16 pixels, and actually only want 8, -+ mask out the last 8 pixels. The 0s don't change the sum. */ -+ perm1 = vec_lvsl(0, pix1); -+ pix1v = (vector unsigned char *) pix1; -+ perm2 = vec_lvsl(0, pix2); -+ pix2v = (vector unsigned char *) pix2; -+ t1 = vec_and(vec_perm(pix1v[0], pix1v[1], perm1), permclear); -+ t2 = vec_and(vec_perm(pix2v[0], pix2v[1], perm2), permclear); -+ -+ /* Calculate a sum of abs differences vector */ -+ t3 = vec_max(t1, t2); -+ t4 = vec_min(t1, t2); -+ t5 = vec_sub(t3, t4); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t5, sad); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ -+ return s; -+} -+ -+int pix_norm1_altivec(uint8_t *pix, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char *tv; -+ vector unsigned char pixv; -+ vector unsigned int sv; -+ vector signed int sum; -+ -+ sv = (vector unsigned int)vec_splat_u32(0); -+ -+ s = 0; -+ for (i = 0; i < 16; i++) { -+ /* Read in the potentially unaligned pixels */ -+ tv = (vector unsigned char *) pix; -+ pixv = vec_perm(tv[0], tv[1], vec_lvsl(0, pix)); -+ -+ /* Square the values, and add them to our sum */ -+ sv = vec_msum(pixv, pixv, sv); -+ -+ pix += line_size; -+ } -+ /* Sum up the four partial sums, and put the result into s */ -+ sum = vec_sums((vector signed int) sv, (vector signed int) zero); -+ sum = vec_splat(sum, 3); -+ vec_ste(sum, 0, &s); -+ -+ return s; -+} -+ -+/** -+ * Sum of Squared Errors for a 8x8 block. -+ * AltiVec-enhanced. -+ * It's the pix_abs8x8_altivec code above w/ squaring added. -+ */ -+int sse8_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char perm1, perm2, permclear, *pix1v, *pix2v; -+ vector unsigned char t1, t2, t3,t4, t5; -+ vector unsigned int sum; -+ vector signed int sumsqr; -+ -+ sum = (vector unsigned int)vec_splat_u32(0); -+ -+ permclear = (vector unsigned char)AVV(255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0); -+ -+ -+ for(i=0;i<8;i++) { -+ /* Read potentially unaligned pixels into t1 and t2 -+ Since we're reading 16 pixels, and actually only want 8, -+ mask out the last 8 pixels. The 0s don't change the sum. */ -+ perm1 = vec_lvsl(0, pix1); -+ pix1v = (vector unsigned char *) pix1; -+ perm2 = vec_lvsl(0, pix2); -+ pix2v = (vector unsigned char *) pix2; -+ t1 = vec_and(vec_perm(pix1v[0], pix1v[1], perm1), permclear); -+ t2 = vec_and(vec_perm(pix2v[0], pix2v[1], perm2), permclear); -+ -+ /* -+ Since we want to use unsigned chars, we can take advantage -+ of the fact that abs(a-b)^2 = (a-b)^2. -+ */ -+ -+ /* Calculate abs differences vector */ -+ t3 = vec_max(t1, t2); -+ t4 = vec_min(t1, t2); -+ t5 = vec_sub(t3, t4); -+ -+ /* Square the values and add them to our sum */ -+ sum = vec_msum(t5, t5, sum); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumsqr = vec_sums((vector signed int) sum, (vector signed int) zero); -+ sumsqr = vec_splat(sumsqr, 3); -+ vec_ste(sumsqr, 0, &s); -+ -+ return s; -+} -+ -+/** -+ * Sum of Squared Errors for a 16x16 block. -+ * AltiVec-enhanced. -+ * It's the pix_abs16x16_altivec code above w/ squaring added. -+ */ -+int sse16_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size) -+{ -+ int i; -+ int s __attribute__((aligned(16))); -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char perm1, perm2, *pix1v, *pix2v; -+ vector unsigned char t1, t2, t3,t4, t5; -+ vector unsigned int sum; -+ vector signed int sumsqr; -+ -+ sum = (vector unsigned int)vec_splat_u32(0); -+ -+ for(i=0;i<16;i++) { -+ /* Read potentially unaligned pixels into t1 and t2 */ -+ perm1 = vec_lvsl(0, pix1); -+ pix1v = (vector unsigned char *) pix1; -+ perm2 = vec_lvsl(0, pix2); -+ pix2v = (vector unsigned char *) pix2; -+ t1 = vec_perm(pix1v[0], pix1v[1], perm1); -+ t2 = vec_perm(pix2v[0], pix2v[1], perm2); -+ -+ /* -+ Since we want to use unsigned chars, we can take advantage -+ of the fact that abs(a-b)^2 = (a-b)^2. -+ */ -+ -+ /* Calculate abs differences vector */ -+ t3 = vec_max(t1, t2); -+ t4 = vec_min(t1, t2); -+ t5 = vec_sub(t3, t4); -+ -+ /* Square the values and add them to our sum */ -+ sum = vec_msum(t5, t5, sum); -+ -+ pix1 += line_size; -+ pix2 += line_size; -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumsqr = vec_sums((vector signed int) sum, (vector signed int) zero); -+ sumsqr = vec_splat(sumsqr, 3); -+ vec_ste(sumsqr, 0, &s); -+ -+ return s; -+} -+ -+int pix_sum_altivec(uint8_t * pix, int line_size) -+{ -+ const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0); -+ vector unsigned char perm, *pixv; -+ vector unsigned char t1; -+ vector unsigned int sad; -+ vector signed int sumdiffs; -+ -+ int i; -+ int s __attribute__((aligned(16))); -+ -+ sad = (vector unsigned int)vec_splat_u32(0); -+ -+ for (i = 0; i < 16; i++) { -+ /* Read the potentially unaligned 16 pixels into t1 */ -+ perm = vec_lvsl(0, pix); -+ pixv = (vector unsigned char *) pix; -+ t1 = vec_perm(pixv[0], pixv[1], perm); -+ -+ /* Add each 4 pixel group together and put 4 results into sad */ -+ sad = vec_sum4s(t1, sad); -+ -+ pix += line_size; -+ } -+ -+ /* Sum up the four partial sums, and put the result into s */ -+ sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero); -+ sumdiffs = vec_splat(sumdiffs, 3); -+ vec_ste(sumdiffs, 0, &s); -+ -+ return s; -+} -+ -+void get_pixels_altivec(DCTELEM *restrict block, const uint8_t *pixels, int line_size) -+{ -+ int i; -+ vector unsigned char perm, bytes, *pixv; -+ const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0); -+ vector signed short shorts; -+ -+ 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. -+ perm = vec_lvsl(0, pixels); -+ pixv = (vector unsigned char *) pixels; -+ bytes = vec_perm(pixv[0], pixv[1], perm); -+ -+ // convert the bytes into shorts -+ shorts = (vector signed short)vec_mergeh(zero, bytes); -+ -+ // save the data to the block, we assume the block is 16-byte aligned -+ vec_st(shorts, i*16, (vector signed short*)block); -+ -+ pixels += line_size; -+ } -+} -+ -+void diff_pixels_altivec(DCTELEM *restrict block, const uint8_t *s1, -+ const uint8_t *s2, int stride) -+{ -+ int i; -+ vector unsigned char perm, bytes, *pixv; -+ 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. -+ perm = vec_lvsl(0, s1); -+ pixv = (vector unsigned char *) s1; -+ bytes = vec_perm(pixv[0], pixv[1], perm); -+ -+ // convert the bytes into shorts -+ shorts1 = (vector signed short)vec_mergeh(zero, bytes); -+ -+ // Do the same for the second block of pixels -+ perm = vec_lvsl(0, s2); -+ pixv = (vector unsigned char *) s2; -+ bytes = vec_perm(pixv[0], pixv[1], perm); -+ -+ // convert the bytes into shorts -+ shorts2 = (vector signed short)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, (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. -+ perm = vec_lvsl(0, s1); -+ pixv = (vector unsigned char *) s1; -+ bytes = vec_perm(pixv[0], pixv[1], perm); -+ -+ // convert the bytes into shorts -+ shorts1 = (vector signed short)vec_mergeh(zero, bytes); -+ -+ // Do the same for the second block of pixels -+ perm = vec_lvsl(0, s2); -+ pixv = (vector unsigned char *) s2; -+ bytes = vec_perm(pixv[0], pixv[1], perm); -+ -+ // convert the bytes into shorts -+ shorts2 = (vector signed short)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, (vector signed short*)block); -+ -+ s1 += stride; -+ s2 += stride; -+ block += 8; -+ } -+} -+ -+int sad16x16_altivec(void *s, uint8_t *a, uint8_t *b, int stride) { -+ return pix_abs16x16_altivec(a,b,stride); -+} -+ -+int sad8x8_altivec(void *s, uint8_t *a, uint8_t *b, int stride) { -+ return pix_abs8x8_altivec(a,b,stride); -+} -+ -+void add_bytes_altivec(uint8_t *dst, uint8_t *src, int w) { -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int i; -+ for(i=0; i+7l); -+ *((uint32_t*)(block+4)) = (((const struct unaligned_32 *) (pixels+4))->l); -+ *((uint32_t*)(block+8)) = (((const struct unaligned_32 *) (pixels+8))->l); -+ *((uint32_t*)(block+12)) = (((const struct unaligned_32 *) (pixels+12))->l); -+ pixels+=line_size; -+ block +=line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register vector unsigned char pixelsv1, pixelsv2; -+ register vector unsigned char pixelsv1B, pixelsv2B; -+ register vector unsigned char pixelsv1C, pixelsv2C; -+ register vector unsigned char pixelsv1D, pixelsv2D; -+ -+ register vector unsigned char perm = vec_lvsl(0, pixels); -+ int i; -+ register int line_size_2 = line_size << 1; -+ register int line_size_3 = line_size + line_size_2; -+ register int line_size_4 = line_size << 2; -+ -+POWERPC_PERF_START_COUNT(altivec_put_pixels16_num, 1); -+// hand-unrolling the loop by 4 gains about 15% -+// mininum execution time goes from 74 to 60 cycles -+// it's faster than -funroll-loops, but using -+// -funroll-loops w/ this is bad - 74 cycles again. -+// all this is on a 7450, tuning for the 7450 -+#if 0 -+ for(i=0; i>1) ) -+void avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h) -+{ -+POWERPC_PERF_DECLARE(altivec_avg_pixels16_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int i; -+ -+POWERPC_PERF_START_COUNT(altivec_avg_pixels16_num, 1); -+ -+ for(i=0; il)); -+ op_avg(*((uint32_t*)(block+4)),(((const struct unaligned_32 *)(pixels+4))->l)); -+ op_avg(*((uint32_t*)(block+8)),(((const struct unaligned_32 *)(pixels+8))->l)); -+ op_avg(*((uint32_t*)(block+12)),(((const struct unaligned_32 *)(pixels+12))->l)); -+ pixels+=line_size; -+ block +=line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_avg_pixels16_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv; -+ register vector unsigned char perm = vec_lvsl(0, pixels); -+ int i; -+ -+POWERPC_PERF_START_COUNT(altivec_avg_pixels16_num, 1); -+ -+ for(i=0; il))) - -+ ((((*((uint32_t *) (block))) ^ -+ ((((const struct unaligned_32 *) (pixels))-> -+ l))) & 0xFEFEFEFEUL) >> 1)); -+ *((uint32_t *) (block + 4)) = -+ (((*((uint32_t *) (block + 4))) | -+ ((((const struct unaligned_32 *) (pixels + 4))->l))) - -+ ((((*((uint32_t *) (block + 4))) ^ -+ ((((const struct unaligned_32 *) (pixels + -+ 4))-> -+ l))) & 0xFEFEFEFEUL) >> 1)); -+ pixels += line_size; -+ block += line_size; -+ } -+POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv; -+ int i; -+ -+POWERPC_PERF_START_COUNT(altivec_avg_pixels8_num, 1); -+ -+ for (i = 0; i < h; i++) { -+ /* -+ block is 8 bytes-aligned, so we're either in the -+ left block (16 bytes-aligned) or in the right block (not) -+ */ -+ int rightside = ((unsigned long)block & 0x0000000F); -+ -+ blockv = vec_ld(0, block); -+ pixelsv1 = vec_ld(0, (unsigned char*)pixels); -+ pixelsv2 = vec_ld(16, (unsigned char*)pixels); -+ pixelsv = vec_perm(pixelsv1, pixelsv2, vec_lvsl(0, pixels)); -+ -+ if (rightside) -+ { -+ pixelsv = vec_perm(blockv, pixelsv, vcprm(0,1,s0,s1)); -+ } -+ else -+ { -+ pixelsv = vec_perm(blockv, pixelsv, vcprm(s0,s1,2,3)); -+ } -+ -+ blockv = vec_avg(blockv, pixelsv); -+ -+ vec_st(blockv, 0, block); -+ -+ pixels += line_size; -+ block += line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_num, 1); -+ -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+/* next one assumes that ((line_size % 8) == 0) */ -+void put_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h) -+{ -+POWERPC_PERF_DECLARE(altivec_put_pixels8_xy2_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int j; -+POWERPC_PERF_START_COUNT(altivec_put_pixels8_xy2_num, 1); -+ for (j = 0; j < 2; j++) { -+ int i; -+ const uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ const uint32_t b = -+ (((const struct unaligned_32 *) (pixels + 1))->l); -+ uint32_t l0 = -+ (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL; -+ uint32_t h0 = -+ ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ uint32_t l1, h1; -+ pixels += line_size; -+ for (i = 0; i < h; i += 2) { -+ uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ uint32_t b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l1 = (a & 0x03030303UL) + (b & 0x03030303UL); -+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ a = (((const struct unaligned_32 *) (pixels))->l); -+ b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL; -+ h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ } pixels += 4 - line_size * (h + 1); -+ block += 4 - line_size * h; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_pixels8_xy2_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register int i; -+ register vector unsigned char -+ pixelsv1, pixelsv2, -+ pixelsavg; -+ register vector unsigned char -+ blockv, temp1, temp2; -+ register vector unsigned short -+ pixelssum1, pixelssum2, temp3; -+ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); -+ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); -+ -+ temp1 = vec_ld(0, pixels); -+ temp2 = vec_ld(16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels)); -+ if ((((unsigned long)pixels) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels)); -+ } -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum1 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ pixelssum1 = vec_add(pixelssum1, vctwo); -+ -+POWERPC_PERF_START_COUNT(altivec_put_pixels8_xy2_num, 1); -+ for (i = 0; i < h ; i++) { -+ int rightside = ((unsigned long)block & 0x0000000F); -+ blockv = vec_ld(0, block); -+ -+ temp1 = vec_ld(line_size, pixels); -+ temp2 = vec_ld(line_size + 16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels)); -+ if (((((unsigned long)pixels) + line_size) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels)); -+ } -+ -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum2 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ temp3 = vec_add(pixelssum1, pixelssum2); -+ temp3 = vec_sra(temp3, vctwo); -+ pixelssum1 = vec_add(pixelssum2, vctwo); -+ pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero); -+ -+ if (rightside) -+ { -+ blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1)); -+ } -+ else -+ { -+ blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3)); -+ } -+ -+ vec_st(blockv, 0, block); -+ -+ block += line_size; -+ pixels += line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_pixels8_xy2_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+/* next one assumes that ((line_size % 8) == 0) */ -+void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h) -+{ -+POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels8_xy2_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int j; -+POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1); -+ for (j = 0; j < 2; j++) { -+ int i; -+ const uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ const uint32_t b = -+ (((const struct unaligned_32 *) (pixels + 1))->l); -+ uint32_t l0 = -+ (a & 0x03030303UL) + (b & 0x03030303UL) + 0x01010101UL; -+ uint32_t h0 = -+ ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ uint32_t l1, h1; -+ pixels += line_size; -+ for (i = 0; i < h; i += 2) { -+ uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ uint32_t b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l1 = (a & 0x03030303UL) + (b & 0x03030303UL); -+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ a = (((const struct unaligned_32 *) (pixels))->l); -+ b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x01010101UL; -+ h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ } pixels += 4 - line_size * (h + 1); -+ block += 4 - line_size * h; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register int i; -+ register vector unsigned char -+ pixelsv1, pixelsv2, -+ pixelsavg; -+ register vector unsigned char -+ blockv, temp1, temp2; -+ register vector unsigned short -+ pixelssum1, pixelssum2, temp3; -+ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); -+ register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1); -+ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); -+ -+ temp1 = vec_ld(0, pixels); -+ temp2 = vec_ld(16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels)); -+ if ((((unsigned long)pixels) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels)); -+ } -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum1 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ pixelssum1 = vec_add(pixelssum1, vcone); -+ -+POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1); -+ for (i = 0; i < h ; i++) { -+ int rightside = ((unsigned long)block & 0x0000000F); -+ blockv = vec_ld(0, block); -+ -+ temp1 = vec_ld(line_size, pixels); -+ temp2 = vec_ld(line_size + 16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels)); -+ if (((((unsigned long)pixels) + line_size) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels)); -+ } -+ -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum2 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ temp3 = vec_add(pixelssum1, pixelssum2); -+ temp3 = vec_sra(temp3, vctwo); -+ pixelssum1 = vec_add(pixelssum2, vcone); -+ pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero); -+ -+ if (rightside) -+ { -+ blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1)); -+ } -+ else -+ { -+ blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3)); -+ } -+ -+ vec_st(blockv, 0, block); -+ -+ block += line_size; -+ pixels += line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+/* next one assumes that ((line_size % 16) == 0) */ -+void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h) -+{ -+POWERPC_PERF_DECLARE(altivec_put_pixels16_xy2_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int j; -+POWERPC_PERF_START_COUNT(altivec_put_pixels16_xy2_num, 1); -+ for (j = 0; j < 4; j++) { -+ int i; -+ const uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ const uint32_t b = -+ (((const struct unaligned_32 *) (pixels + 1))->l); -+ uint32_t l0 = -+ (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL; -+ uint32_t h0 = -+ ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ uint32_t l1, h1; -+ pixels += line_size; -+ for (i = 0; i < h; i += 2) { -+ uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ uint32_t b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l1 = (a & 0x03030303UL) + (b & 0x03030303UL); -+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ a = (((const struct unaligned_32 *) (pixels))->l); -+ b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x02020202UL; -+ h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ } pixels += 4 - line_size * (h + 1); -+ block += 4 - line_size * h; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_xy2_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register int i; -+ register vector unsigned char -+ pixelsv1, pixelsv2, pixelsv3, pixelsv4; -+ register vector unsigned char -+ blockv, temp1, temp2; -+ register vector unsigned short -+ pixelssum1, pixelssum2, temp3, -+ pixelssum3, pixelssum4, temp4; -+ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); -+ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); -+ -+POWERPC_PERF_START_COUNT(altivec_put_pixels16_xy2_num, 1); -+ -+ temp1 = vec_ld(0, pixels); -+ temp2 = vec_ld(16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels)); -+ if ((((unsigned long)pixels) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels)); -+ } -+ pixelsv3 = vec_mergel(vczero, pixelsv1); -+ pixelsv4 = vec_mergel(vczero, pixelsv2); -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum3 = vec_add((vector unsigned short)pixelsv3, -+ (vector unsigned short)pixelsv4); -+ pixelssum3 = vec_add(pixelssum3, vctwo); -+ pixelssum1 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ pixelssum1 = vec_add(pixelssum1, vctwo); -+ -+ for (i = 0; i < h ; i++) { -+ blockv = vec_ld(0, block); -+ -+ temp1 = vec_ld(line_size, pixels); -+ temp2 = vec_ld(line_size + 16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels)); -+ if (((((unsigned long)pixels) + line_size) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels)); -+ } -+ -+ pixelsv3 = vec_mergel(vczero, pixelsv1); -+ pixelsv4 = vec_mergel(vczero, pixelsv2); -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ -+ pixelssum4 = vec_add((vector unsigned short)pixelsv3, -+ (vector unsigned short)pixelsv4); -+ pixelssum2 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ temp4 = vec_add(pixelssum3, pixelssum4); -+ temp4 = vec_sra(temp4, vctwo); -+ temp3 = vec_add(pixelssum1, pixelssum2); -+ temp3 = vec_sra(temp3, vctwo); -+ -+ pixelssum3 = vec_add(pixelssum4, vctwo); -+ pixelssum1 = vec_add(pixelssum2, vctwo); -+ -+ blockv = vec_packsu(temp3, temp4); -+ -+ vec_st(blockv, 0, block); -+ -+ block += line_size; -+ pixels += line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_xy2_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+/* next one assumes that ((line_size % 16) == 0) */ -+void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h) -+{ -+POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels16_xy2_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int j; -+POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1); -+ for (j = 0; j < 4; j++) { -+ int i; -+ const uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ const uint32_t b = -+ (((const struct unaligned_32 *) (pixels + 1))->l); -+ uint32_t l0 = -+ (a & 0x03030303UL) + (b & 0x03030303UL) + 0x01010101UL; -+ uint32_t h0 = -+ ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ uint32_t l1, h1; -+ pixels += line_size; -+ for (i = 0; i < h; i += 2) { -+ uint32_t a = (((const struct unaligned_32 *) (pixels))->l); -+ uint32_t b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l1 = (a & 0x03030303UL) + (b & 0x03030303UL); -+ h1 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ a = (((const struct unaligned_32 *) (pixels))->l); -+ b = (((const struct unaligned_32 *) (pixels + 1))->l); -+ l0 = (a & 0x03030303UL) + (b & 0x03030303UL) + 0x01010101UL; -+ h0 = ((a & 0xFCFCFCFCUL) >> 2) + ((b & 0xFCFCFCFCUL) >> 2); -+ *((uint32_t *) block) = -+ h0 + h1 + (((l0 + l1) >> 2) & 0x0F0F0F0FUL); -+ pixels += line_size; -+ block += line_size; -+ } pixels += 4 - line_size * (h + 1); -+ block += 4 - line_size * h; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ register int i; -+ register vector unsigned char -+ pixelsv1, pixelsv2, pixelsv3, pixelsv4; -+ register vector unsigned char -+ blockv, temp1, temp2; -+ register vector unsigned short -+ pixelssum1, pixelssum2, temp3, -+ pixelssum3, pixelssum4, temp4; -+ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); -+ register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1); -+ register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2); -+ -+POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1); -+ -+ temp1 = vec_ld(0, pixels); -+ temp2 = vec_ld(16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels)); -+ if ((((unsigned long)pixels) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels)); -+ } -+ pixelsv3 = vec_mergel(vczero, pixelsv1); -+ pixelsv4 = vec_mergel(vczero, pixelsv2); -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ pixelssum3 = vec_add((vector unsigned short)pixelsv3, -+ (vector unsigned short)pixelsv4); -+ pixelssum3 = vec_add(pixelssum3, vcone); -+ pixelssum1 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ pixelssum1 = vec_add(pixelssum1, vcone); -+ -+ for (i = 0; i < h ; i++) { -+ blockv = vec_ld(0, block); -+ -+ temp1 = vec_ld(line_size, pixels); -+ temp2 = vec_ld(line_size + 16, pixels); -+ pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels)); -+ if (((((unsigned long)pixels) + line_size) & 0x0000000F) == 0x0000000F) -+ { -+ pixelsv2 = temp2; -+ } -+ else -+ { -+ pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels)); -+ } -+ -+ pixelsv3 = vec_mergel(vczero, pixelsv1); -+ pixelsv4 = vec_mergel(vczero, pixelsv2); -+ pixelsv1 = vec_mergeh(vczero, pixelsv1); -+ pixelsv2 = vec_mergeh(vczero, pixelsv2); -+ -+ pixelssum4 = vec_add((vector unsigned short)pixelsv3, -+ (vector unsigned short)pixelsv4); -+ pixelssum2 = vec_add((vector unsigned short)pixelsv1, -+ (vector unsigned short)pixelsv2); -+ temp4 = vec_add(pixelssum3, pixelssum4); -+ temp4 = vec_sra(temp4, vctwo); -+ temp3 = vec_add(pixelssum1, pixelssum2); -+ temp3 = vec_sra(temp3, vctwo); -+ -+ pixelssum3 = vec_add(pixelssum4, vcone); -+ pixelssum1 = vec_add(pixelssum2, vcone); -+ -+ blockv = vec_packsu(temp3, temp4); -+ -+ vec_st(blockv, 0, block); -+ -+ block += line_size; -+ pixels += line_size; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+int has_altivec(void) -+{ -+#ifdef CONFIG_DARWIN -+ int sels[2] = {CTL_HW, HW_VECTORUNIT}; -+ 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 != 0); -+#else /* CONFIG_DARWIN */ -+/* no Darwin, do it the brute-force way */ -+/* this is borrowed from the libmpeg2 library */ -+ { -+ signal (SIGILL, sigill_handler); -+ if (sigsetjmp (jmpbuf, 1)) { -+ signal (SIGILL, SIG_DFL); -+ } else { -+ canjump = 1; -+ -+ asm volatile ("mtspr 256, %0\n\t" -+ "vand %%v0, %%v0, %%v0" -+ : -+ : "r" (-1)); -+ -+ signal (SIGILL, SIG_DFL); -+ return 1; -+ } -+ } -+#endif /* CONFIG_DARWIN */ -+ return 0; -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/dsputil_ppc.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/dsputil_ppc.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/dsputil_ppc.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/dsputil_ppc.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,307 @@ -+/* -+ * Copyright (c) 2002 Brian Foley -+ * Copyright (c) 2002 Dieter Shirley -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "../dsputil.h" -+ -+#include "dsputil_ppc.h" -+ -+#ifdef HAVE_ALTIVEC -+#include "dsputil_altivec.h" -+#endif -+ -+extern void idct_put_altivec(uint8_t *dest, int line_size, int16_t *block); -+extern void idct_add_altivec(uint8_t *dest, int line_size, int16_t *block); -+ -+int mm_flags = 0; -+ -+int mm_support(void) -+{ -+ int result = 0; -+#if HAVE_ALTIVEC -+ if (has_altivec()) { -+ result |= MM_ALTIVEC; -+ } -+#endif /* result */ -+ return result; -+} -+ -+#ifdef POWERPC_PERFORMANCE_REPORT -+unsigned long long perfdata[POWERPC_NUM_PMC_ENABLED][powerpc_perf_total][powerpc_data_total]; -+/* list below must match enum in dsputil_ppc.h */ -+static unsigned char* perfname[] = { -+ "fft_calc_altivec", -+ "gmc1_altivec", -+ "dct_unquantize_h263_altivec", -+ "idct_add_altivec", -+ "idct_put_altivec", -+ "put_pixels16_altivec", -+ "avg_pixels16_altivec", -+ "avg_pixels8_altivec", -+ "put_pixels8_xy2_altivec", -+ "put_no_rnd_pixels8_xy2_altivec", -+ "put_pixels16_xy2_altivec", -+ "put_no_rnd_pixels16_xy2_altivec", -+ "clear_blocks_dcbz32_ppc", -+ "clear_blocks_dcbz128_ppc" -+}; -+#include -+#endif -+ -+#ifdef POWERPC_PERFORMANCE_REPORT -+void powerpc_display_perf_report(void) -+{ -+ int i, j; -+ fprintf(stderr, "PowerPC performance report\n Values are from the PMC registers, and represent whatever the registers are set to record.\n"); -+ for(i = 0 ; i < powerpc_perf_total ; i++) -+ { -+ for (j = 0; j < POWERPC_NUM_PMC_ENABLED ; j++) -+ { -+ if (perfdata[j][i][powerpc_data_num] != (unsigned long long)0) -+ fprintf(stderr, -+ " Function \"%s\" (pmc%d):\n\tmin: %llu\n\tmax: %llu\n\tavg: %1.2lf (%llu)\n", -+ perfname[i], -+ j+1, -+ perfdata[j][i][powerpc_data_min], -+ perfdata[j][i][powerpc_data_max], -+ (double)perfdata[j][i][powerpc_data_sum] / -+ (double)perfdata[j][i][powerpc_data_num], -+ perfdata[j][i][powerpc_data_num]); -+ } -+ } -+} -+#endif /* POWERPC_PERFORMANCE_REPORT */ -+ -+/* ***** WARNING ***** WARNING ***** WARNING ***** */ -+/* -+ clear_blocks_dcbz32_ppc will not work properly -+ on PowerPC processors with a cache line size -+ not equal to 32 bytes. -+ Fortunately all processor used by Apple up to -+ at least the 7450 (aka second generation G4) -+ use 32 bytes cache line. -+ This is due to the use of the 'dcbz' instruction. -+ It simply clear to zero a single cache line, -+ so you need to know the cache line size to use it ! -+ It's absurd, but it's fast... -+ -+ update 24/06/2003 : Apple released yesterday the G5, -+ with a PPC970. cache line size : 128 bytes. Oups. -+ The semantic of dcbz was changed, it always clear -+ 32 bytes. so the function below will work, but will -+ be slow. So I fixed check_dcbz_effect to use dcbzl, -+ which is defined to clear a cache line (as dcbz before). -+ So we still can distinguish, and use dcbz (32 bytes) -+ or dcbzl (one cache line) as required. -+ -+ see -+ and -+*/ -+void clear_blocks_dcbz32_ppc(DCTELEM *blocks) -+{ -+POWERPC_PERF_DECLARE(powerpc_clear_blocks_dcbz32, 1); -+ register int misal = ((unsigned long)blocks & 0x00000010); -+ register int i = 0; -+POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz32, 1); -+#if 1 -+ if (misal) { -+ ((unsigned long*)blocks)[0] = 0L; -+ ((unsigned long*)blocks)[1] = 0L; -+ ((unsigned long*)blocks)[2] = 0L; -+ ((unsigned long*)blocks)[3] = 0L; -+ i += 16; -+ } -+ for ( ; i < sizeof(DCTELEM)*6*64 ; i += 32) { -+ asm volatile("dcbz %0,%1" : : "b" (blocks), "r" (i) : "memory"); -+ } -+ if (misal) { -+ ((unsigned long*)blocks)[188] = 0L; -+ ((unsigned long*)blocks)[189] = 0L; -+ ((unsigned long*)blocks)[190] = 0L; -+ ((unsigned long*)blocks)[191] = 0L; -+ i += 16; -+ } -+#else -+ memset(blocks, 0, sizeof(DCTELEM)*6*64); -+#endif -+POWERPC_PERF_STOP_COUNT(powerpc_clear_blocks_dcbz32, 1); -+} -+ -+/* same as above, when dcbzl clear a whole 128B cache line -+ i.e. the PPC970 aka G5 */ -+#ifndef NO_DCBZL -+void clear_blocks_dcbz128_ppc(DCTELEM *blocks) -+{ -+POWERPC_PERF_DECLARE(powerpc_clear_blocks_dcbz128, 1); -+ register int misal = ((unsigned long)blocks & 0x0000007f); -+ register int i = 0; -+POWERPC_PERF_START_COUNT(powerpc_clear_blocks_dcbz128, 1); -+#if 1 -+ if (misal) { -+ // we could probably also optimize this case, -+ // but there's not much point as the machines -+ // aren't available yet (2003-06-26) -+ memset(blocks, 0, sizeof(DCTELEM)*6*64); -+ } -+ else -+ for ( ; i < sizeof(DCTELEM)*6*64 ; i += 128) { -+ asm volatile("dcbzl %0,%1" : : "b" (blocks), "r" (i) : "memory"); -+ } -+#else -+ memset(blocks, 0, sizeof(DCTELEM)*6*64); -+#endif -+POWERPC_PERF_STOP_COUNT(powerpc_clear_blocks_dcbz128, 1); -+} -+#else -+void clear_blocks_dcbz128_ppc(DCTELEM *blocks) -+{ -+ memset(blocks, 0, sizeof(DCTELEM)*6*64); -+} -+#endif -+ -+#ifndef NO_DCBZL -+/* check dcbz report how many bytes are set to 0 by dcbz */ -+/* update 24/06/2003 : replace dcbz by dcbzl to get -+ the intended effect (Apple "fixed" dcbz) -+ unfortunately this cannot be used unless the assembler -+ knows about dcbzl ... */ -+long check_dcbzl_effect(void) -+{ -+ register char *fakedata = (char*)av_malloc(1024); -+ register char *fakedata_middle; -+ register long zero = 0; -+ register long i = 0; -+ long count = 0; -+ -+ if (!fakedata) -+ { -+ return 0L; -+ } -+ -+ fakedata_middle = (fakedata + 512); -+ -+ memset(fakedata, 0xFF, 1024); -+ -+ /* below the constraint "b" seems to mean "Address base register" -+ in gcc-3.3 / RS/6000 speaks. seems to avoid using r0, so.... */ -+ asm volatile("dcbzl %0, %1" : : "b" (fakedata_middle), "r" (zero)); -+ -+ for (i = 0; i < 1024 ; i ++) -+ { -+ if (fakedata[i] == (char)0) -+ count++; -+ } -+ -+ av_free(fakedata); -+ -+ return count; -+} -+#else -+long check_dcbzl_effect(void) -+{ -+ return 0; -+} -+#endif -+ -+void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx) -+{ -+ // Common optimizations whether Altivec is available or not -+ -+ switch (check_dcbzl_effect()) { -+ case 32: -+ c->clear_blocks = clear_blocks_dcbz32_ppc; -+ break; -+ case 128: -+ c->clear_blocks = clear_blocks_dcbz128_ppc; -+ break; -+ default: -+ break; -+ } -+ -+#if HAVE_ALTIVEC -+ if (has_altivec()) { -+ mm_flags |= MM_ALTIVEC; -+ -+ // Altivec specific optimisations -+ c->pix_abs16x16_x2 = pix_abs16x16_x2_altivec; -+ c->pix_abs16x16_y2 = pix_abs16x16_y2_altivec; -+ c->pix_abs16x16_xy2 = pix_abs16x16_xy2_altivec; -+ c->pix_abs16x16 = pix_abs16x16_altivec; -+ c->pix_abs8x8 = pix_abs8x8_altivec; -+ c->sad[0]= sad16x16_altivec; -+ c->sad[1]= sad8x8_altivec; -+ c->pix_norm1 = pix_norm1_altivec; -+ c->sse[1]= sse8_altivec; -+ c->sse[0]= sse16_altivec; -+ c->pix_sum = pix_sum_altivec; -+ c->diff_pixels = diff_pixels_altivec; -+ c->get_pixels = get_pixels_altivec; -+// next one disabled as it's untested. -+#if 0 -+ c->add_bytes= add_bytes_altivec; -+#endif /* 0 */ -+ c->put_pixels_tab[0][0] = put_pixels16_altivec; -+ /* the tow functions do the same thing, so use the same code */ -+ c->put_no_rnd_pixels_tab[0][0] = put_pixels16_altivec; -+ c->avg_pixels_tab[0][0] = avg_pixels16_altivec; -+// next one disabled as it's untested. -+#if 0 -+ c->avg_pixels_tab[1][0] = avg_pixels8_altivec; -+#endif /* 0 */ -+ c->put_pixels_tab[1][3] = put_pixels8_xy2_altivec; -+ c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_altivec; -+ c->put_pixels_tab[0][3] = put_pixels16_xy2_altivec; -+ c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_altivec; -+ -+ c->gmc1 = gmc1_altivec; -+ -+ if ((avctx->idct_algo == FF_IDCT_AUTO) || -+ (avctx->idct_algo == FF_IDCT_ALTIVEC)) -+ { -+ c->idct_put = idct_put_altivec; -+ c->idct_add = idct_add_altivec; -+#ifndef ALTIVEC_USE_REFERENCE_C_CODE -+ c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM; -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ c->idct_permutation_type = FF_NO_IDCT_PERM; -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ } -+ -+#ifdef POWERPC_PERFORMANCE_REPORT -+ { -+ int i, j; -+ for (i = 0 ; i < powerpc_perf_total ; i++) -+ { -+ for (j = 0; j < POWERPC_NUM_PMC_ENABLED ; j++) -+ { -+ perfdata[j][i][powerpc_data_min] = (unsigned long long)0xFFFFFFFFFFFFFFFF; -+ perfdata[j][i][powerpc_data_max] = (unsigned long long)0x0000000000000000; -+ perfdata[j][i][powerpc_data_sum] = (unsigned long long)0x0000000000000000; -+ perfdata[j][i][powerpc_data_num] = (unsigned long long)0x0000000000000000; -+ } -+ } -+ } -+#endif /* POWERPC_PERFORMANCE_REPORT */ -+ } else -+#endif /* HAVE_ALTIVEC */ -+ { -+ // Non-AltiVec PPC optimisations -+ -+ // ... pending ... -+ } -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/fft_altivec.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/fft_altivec.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/fft_altivec.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/fft_altivec.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,247 @@ -+/* -+ * FFT/IFFT transforms -+ * AltiVec-enabled -+ * Copyright (c) 2003 Romain Dolbeau -+ * Based on code Copyright (c) 2002 Fabrice Bellard. -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+#include "../dsputil.h" -+ -+#include "gcc_fixes.h" -+ -+#include "dsputil_altivec.h" -+ -+/* -+ those three macros are from libavcodec/fft.c -+ and are required for the reference C code -+*/ -+/* butter fly op */ -+#define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \ -+{\ -+ FFTSample ax, ay, bx, by;\ -+ bx=pre1;\ -+ by=pim1;\ -+ ax=qre1;\ -+ ay=qim1;\ -+ pre = (bx + ax);\ -+ pim = (by + ay);\ -+ qre = (bx - ax);\ -+ qim = (by - ay);\ -+} -+#define MUL16(a,b) ((a) * (b)) -+#define CMUL(pre, pim, are, aim, bre, bim) \ -+{\ -+ pre = (MUL16(are, bre) - MUL16(aim, bim));\ -+ pim = (MUL16(are, bim) + MUL16(bre, aim));\ -+} -+ -+ -+/** -+ * Do a complex FFT with the parameters defined in fft_init(). The -+ * input data must be permuted before with s->revtab table. No -+ * 1.0/sqrt(n) normalization is done. -+ * AltiVec-enabled -+ * This code assumes that the 'z' pointer is 16 bytes-aligned -+ * It also assumes all FFTComplex are 8 bytes-aligned pair of float -+ * The code is exactly the same as the SSE version, except -+ * that successive MUL + ADD/SUB have been merged into -+ * fused multiply-add ('vec_madd' in altivec) -+ */ -+void fft_calc_altivec(FFTContext *s, FFTComplex *z) -+{ -+POWERPC_PERF_DECLARE(altivec_fft_num, s->nbits >= 6); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ int ln = s->nbits; -+ int j, np, np2; -+ int nblocks, nloops; -+ register FFTComplex *p, *q; -+ FFTComplex *exptab = s->exptab; -+ int l; -+ FFTSample tmp_re, tmp_im; -+ -+POWERPC_PERF_START_COUNT(altivec_fft_num, s->nbits >= 6); -+ -+ np = 1 << ln; -+ -+ /* pass 0 */ -+ -+ p=&z[0]; -+ j=(np >> 1); -+ do { -+ BF(p[0].re, p[0].im, p[1].re, p[1].im, -+ p[0].re, p[0].im, p[1].re, p[1].im); -+ p+=2; -+ } while (--j != 0); -+ -+ /* pass 1 */ -+ -+ -+ p=&z[0]; -+ j=np >> 2; -+ if (s->inverse) { -+ do { -+ BF(p[0].re, p[0].im, p[2].re, p[2].im, -+ p[0].re, p[0].im, p[2].re, p[2].im); -+ BF(p[1].re, p[1].im, p[3].re, p[3].im, -+ p[1].re, p[1].im, -p[3].im, p[3].re); -+ p+=4; -+ } while (--j != 0); -+ } else { -+ do { -+ BF(p[0].re, p[0].im, p[2].re, p[2].im, -+ p[0].re, p[0].im, p[2].re, p[2].im); -+ BF(p[1].re, p[1].im, p[3].re, p[3].im, -+ p[1].re, p[1].im, p[3].im, -p[3].re); -+ p+=4; -+ } while (--j != 0); -+ } -+ /* pass 2 .. ln-1 */ -+ -+ nblocks = np >> 3; -+ nloops = 1 << 2; -+ np2 = np >> 1; -+ do { -+ p = z; -+ q = z + nloops; -+ for (j = 0; j < nblocks; ++j) { -+ BF(p->re, p->im, q->re, q->im, -+ p->re, p->im, q->re, q->im); -+ -+ p++; -+ q++; -+ for(l = nblocks; l < np2; l += nblocks) { -+ CMUL(tmp_re, tmp_im, exptab[l].re, exptab[l].im, q->re, q->im); -+ BF(p->re, p->im, q->re, q->im, -+ p->re, p->im, tmp_re, tmp_im); -+ p++; -+ q++; -+ } -+ -+ p += nloops; -+ q += nloops; -+ } -+ nblocks = nblocks >> 1; -+ nloops = nloops << 1; -+ } while (nblocks != 0); -+ -+POWERPC_PERF_STOP_COUNT(altivec_fft_num, s->nbits >= 6); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+#ifdef CONFIG_DARWIN -+ register const vector float vczero = (const vector float)(0.); -+#else -+ register const vector float vczero = (const vector float){0.,0.,0.,0.}; -+#endif -+ -+ int ln = s->nbits; -+ int j, np, np2; -+ int nblocks, nloops; -+ register FFTComplex *p, *q; -+ FFTComplex *cptr, *cptr1; -+ int k; -+ -+POWERPC_PERF_START_COUNT(altivec_fft_num, s->nbits >= 6); -+ -+ np = 1 << ln; -+ -+ { -+ vector float *r, a, b, a1, c1, c2; -+ -+ r = (vector float *)&z[0]; -+ -+ c1 = vcii(p,p,n,n); -+ -+ if (s->inverse) -+ { -+ c2 = vcii(p,p,n,p); -+ } -+ else -+ { -+ c2 = vcii(p,p,p,n); -+ } -+ -+ j = (np >> 2); -+ do { -+ a = vec_ld(0, r); -+ a1 = vec_ld(sizeof(vector float), r); -+ -+ b = vec_perm(a,a,vcprmle(1,0,3,2)); -+ a = vec_madd(a,c1,b); -+ /* do the pass 0 butterfly */ -+ -+ b = vec_perm(a1,a1,vcprmle(1,0,3,2)); -+ b = vec_madd(a1,c1,b); -+ /* do the pass 0 butterfly */ -+ -+ /* multiply third by -i */ -+ b = vec_perm(b,b,vcprmle(2,3,1,0)); -+ -+ /* do the pass 1 butterfly */ -+ vec_st(vec_madd(b,c2,a), 0, r); -+ vec_st(vec_nmsub(b,c2,a), sizeof(vector float), r); -+ -+ r += 2; -+ } while (--j != 0); -+ } -+ /* pass 2 .. ln-1 */ -+ -+ nblocks = np >> 3; -+ nloops = 1 << 2; -+ np2 = np >> 1; -+ -+ cptr1 = s->exptab1; -+ do { -+ p = z; -+ q = z + nloops; -+ j = nblocks; -+ do { -+ cptr = cptr1; -+ k = nloops >> 1; -+ do { -+ vector float a,b,c,t1; -+ -+ a = vec_ld(0, (float*)p); -+ b = vec_ld(0, (float*)q); -+ -+ /* complex mul */ -+ c = vec_ld(0, (float*)cptr); -+ /* cre*re cim*re */ -+ t1 = vec_madd(c, vec_perm(b,b,vcprmle(2,2,0,0)),vczero); -+ c = vec_ld(sizeof(vector float), (float*)cptr); -+ /* -cim*im cre*im */ -+ b = vec_madd(c, vec_perm(b,b,vcprmle(3,3,1,1)),t1); -+ -+ /* butterfly */ -+ vec_st(vec_add(a,b), 0, (float*)p); -+ vec_st(vec_sub(a,b), 0, (float*)q); -+ -+ p += 2; -+ q += 2; -+ cptr += 4; -+ } while (--k); -+ -+ p += nloops; -+ q += nloops; -+ } while (--j); -+ cptr1 += nloops * 2; -+ nblocks = nblocks >> 1; -+ nloops = nloops << 1; -+ } while (nblocks != 0); -+ -+POWERPC_PERF_STOP_COUNT(altivec_fft_num, s->nbits >= 6); -+ -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/gcc_fixes.h avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/gcc_fixes.h ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/gcc_fixes.h 2003-07-04 15:40:29.000000000 +0200 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/gcc_fixes.h 2003-09-28 17:26:40.000000000 +0200 -@@ -25,7 +25,7 @@ - * http://gcc.gnu.org/ml/gcc/2003-04/msg00967.html - */ - --static inline vector signed char my_vmrglb (vector signed char const A, -+static inline vector signed char ff_vmrglb (vector signed char const A, - vector signed char const B) - { - static const vector unsigned char lowbyte = { -@@ -35,7 +35,7 @@ - return vec_perm (A, B, lowbyte); - } - --static inline vector signed short my_vmrglh (vector signed short const A, -+static inline vector signed short ff_vmrglh (vector signed short const A, - vector signed short const B) - { - static const vector unsigned char lowhalf = { -@@ -45,7 +45,7 @@ - return vec_perm (A, B, lowhalf); - } - --static inline vector signed int my_vmrglw (vector signed int const A, -+static inline vector signed int ff_vmrglw (vector signed int const A, - vector signed int const B) - { - static const vector unsigned char lowword = { -@@ -54,27 +54,27 @@ - }; - return vec_perm (A, B, lowword); - } --/*#define my_vmrglb my_vmrglb --#define my_vmrglh my_vmrglh --#define my_vmrglw my_vmrglw -+/*#define ff_vmrglb ff_vmrglb -+#define ff_vmrglh ff_vmrglh -+#define ff_vmrglw ff_vmrglw - */ - #undef vec_mergel - - #define vec_mergel(a1, a2) \ - __ch (__bin_args_eq (vector signed char, (a1), vector signed char, (a2)), \ -- ((vector signed char) my_vmrglb ((vector signed char) (a1), (vector signed char) (a2))), \ -+ ((vector signed char) ff_vmrglb ((vector signed char) (a1), (vector signed char) (a2))), \ - __ch (__bin_args_eq (vector unsigned char, (a1), vector unsigned char, (a2)), \ -- ((vector unsigned char) my_vmrglb ((vector signed char) (a1), (vector signed char) (a2))), \ -+ ((vector unsigned char) ff_vmrglb ((vector signed char) (a1), (vector signed char) (a2))), \ - __ch (__bin_args_eq (vector signed short, (a1), vector signed short, (a2)), \ -- ((vector signed short) my_vmrglh ((vector signed short) (a1), (vector signed short) (a2))), \ -+ ((vector signed short) ff_vmrglh ((vector signed short) (a1), (vector signed short) (a2))), \ - __ch (__bin_args_eq (vector unsigned short, (a1), vector unsigned short, (a2)), \ -- ((vector unsigned short) my_vmrglh ((vector signed short) (a1), (vector signed short) (a2))), \ -+ ((vector unsigned short) ff_vmrglh ((vector signed short) (a1), (vector signed short) (a2))), \ - __ch (__bin_args_eq (vector float, (a1), vector float, (a2)), \ -- ((vector float) my_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ -+ ((vector float) ff_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ - __ch (__bin_args_eq (vector signed int, (a1), vector signed int, (a2)), \ -- ((vector signed int) my_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ -+ ((vector signed int) ff_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ - __ch (__bin_args_eq (vector unsigned int, (a1), vector unsigned int, (a2)), \ -- ((vector unsigned int) my_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ -+ ((vector unsigned int) ff_vmrglw ((vector signed int) (a1), (vector signed int) (a2))), \ - __altivec_link_error_invalid_argument ()))))))) - - #endif -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/gmc_altivec.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/gmc_altivec.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/gmc_altivec.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/gmc_altivec.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,172 @@ -+/* -+ * GMC (Global Motion Compensation) -+ * AltiVec-enabled -+ * Copyright (c) 2003 Romain Dolbeau -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "../dsputil.h" -+ -+#include "gcc_fixes.h" -+ -+#include "dsputil_altivec.h" -+ -+/* -+ altivec-enhanced gmc1. ATM this code assume stride is a multiple of 8, -+ to preserve proper dst alignement. -+*/ -+#define GMC1_PERF_COND (h==8) -+void gmc1_altivec(uint8_t *dst /* align 8 */, uint8_t *src /* align1 */, int stride, int h, int x16, int y16, int rounder) -+{ -+POWERPC_PERF_DECLARE(altivec_gmc1_num, GMC1_PERF_COND); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ const int A=(16-x16)*(16-y16); -+ const int B=( x16)*(16-y16); -+ const int C=(16-x16)*( y16); -+ const int D=( x16)*( y16); -+ int i; -+ -+POWERPC_PERF_START_COUNT(altivec_gmc1_num, GMC1_PERF_COND); -+ -+ for(i=0; i>8; -+ dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8; -+ dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8; -+ dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8; -+ dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8; -+ dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8; -+ dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8; -+ dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8; -+ dst+= stride; -+ src+= stride; -+ } -+ -+POWERPC_PERF_STOP_COUNT(altivec_gmc1_num, GMC1_PERF_COND); -+ -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ const unsigned short __attribute__ ((aligned(16))) rounder_a[8] = -+ {rounder, rounder, rounder, rounder, -+ rounder, rounder, rounder, rounder}; -+ const unsigned short __attribute__ ((aligned(16))) ABCD[8] = -+ { -+ (16-x16)*(16-y16), /* A */ -+ ( x16)*(16-y16), /* B */ -+ (16-x16)*( y16), /* C */ -+ ( x16)*( y16), /* D */ -+ 0, 0, 0, 0 /* padding */ -+ }; -+ register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0); -+ register const vector unsigned short vcsr8 = (const vector unsigned short)vec_splat_u16(8); -+ register vector unsigned char dstv, dstv2, src_0, src_1, srcvA, srcvB, srcvC, srcvD; -+ register vector unsigned short Av, Bv, Cv, Dv, rounderV, tempA, tempB, tempC, tempD; -+ int i; -+ unsigned long dst_odd = (unsigned long)dst & 0x0000000F; -+ unsigned long src_really_odd = (unsigned long)src & 0x0000000F; -+ -+ -+POWERPC_PERF_START_COUNT(altivec_gmc1_num, GMC1_PERF_COND); -+ -+ tempA = vec_ld(0, (unsigned short*)ABCD); -+ Av = vec_splat(tempA, 0); -+ Bv = vec_splat(tempA, 1); -+ Cv = vec_splat(tempA, 2); -+ Dv = vec_splat(tempA, 3); -+ -+ rounderV = vec_ld(0, (unsigned short*)rounder_a); -+ -+ // we'll be able to pick-up our 9 char elements -+ // at src from those 32 bytes -+ // we load the first batch here, as inside the loop -+ // we can re-use 'src+stride' from one iteration -+ // as the 'src' of the next. -+ src_0 = vec_ld(0, src); -+ src_1 = vec_ld(16, src); -+ srcvA = vec_perm(src_0, src_1, vec_lvsl(0, src)); -+ -+ if (src_really_odd != 0x0000000F) -+ { // if src & 0xF == 0xF, then (src+1) is properly aligned on the second vector. -+ srcvB = vec_perm(src_0, src_1, vec_lvsl(1, src)); -+ } -+ else -+ { -+ srcvB = src_1; -+ } -+ srcvA = vec_mergeh(vczero, srcvA); -+ srcvB = vec_mergeh(vczero, srcvB); -+ -+ for(i=0; i /* malloc(), free() */ -+#include -+#include "../dsputil.h" -+ -+#include "gcc_fixes.h" -+ -+#include "dsputil_altivec.h" -+ -+#define vector_s16_t vector signed short -+#define vector_u16_t vector unsigned short -+#define vector_s8_t vector signed char -+#define vector_u8_t vector unsigned char -+#define vector_s32_t vector signed int -+#define vector_u32_t vector unsigned int -+ -+#define IDCT_HALF \ -+ /* 1st stage */ \ -+ t1 = vec_mradds (a1, vx7, vx1 ); \ -+ t8 = vec_mradds (a1, vx1, vec_subs (zero, vx7)); \ -+ t7 = vec_mradds (a2, vx5, vx3); \ -+ t3 = vec_mradds (ma2, vx3, vx5); \ -+ \ -+ /* 2nd stage */ \ -+ t5 = vec_adds (vx0, vx4); \ -+ t0 = vec_subs (vx0, vx4); \ -+ t2 = vec_mradds (a0, vx6, vx2); \ -+ t4 = vec_mradds (a0, vx2, vec_subs (zero, vx6)); \ -+ t6 = vec_adds (t8, t3); \ -+ t3 = vec_subs (t8, t3); \ -+ t8 = vec_subs (t1, t7); \ -+ t1 = vec_adds (t1, t7); \ -+ \ -+ /* 3rd stage */ \ -+ t7 = vec_adds (t5, t2); \ -+ t2 = vec_subs (t5, t2); \ -+ t5 = vec_adds (t0, t4); \ -+ t0 = vec_subs (t0, t4); \ -+ t4 = vec_subs (t8, t3); \ -+ t3 = vec_adds (t8, t3); \ -+ \ -+ /* 4th stage */ \ -+ vy0 = vec_adds (t7, t1); \ -+ vy7 = vec_subs (t7, t1); \ -+ vy1 = vec_mradds (c4, t3, t5); \ -+ vy6 = vec_mradds (mc4, t3, t5); \ -+ vy2 = vec_mradds (c4, t4, t0); \ -+ vy5 = vec_mradds (mc4, t4, t0); \ -+ vy3 = vec_adds (t2, t6); \ -+ vy4 = vec_subs (t2, t6); -+ -+ -+#define IDCT \ -+ vector_s16_t vx0, vx1, vx2, vx3, vx4, vx5, vx6, vx7; \ -+ vector_s16_t vy0, vy1, vy2, vy3, vy4, vy5, vy6, vy7; \ -+ vector_s16_t a0, a1, a2, ma2, c4, mc4, zero, bias; \ -+ vector_s16_t t0, t1, t2, t3, t4, t5, t6, t7, t8; \ -+ vector_u16_t shift; \ -+ \ -+ c4 = vec_splat (constants[0], 0); \ -+ a0 = vec_splat (constants[0], 1); \ -+ a1 = vec_splat (constants[0], 2); \ -+ a2 = vec_splat (constants[0], 3); \ -+ mc4 = vec_splat (constants[0], 4); \ -+ ma2 = vec_splat (constants[0], 5); \ -+ bias = (vector_s16_t)vec_splat ((vector_s32_t)constants[0], 3); \ -+ \ -+ zero = vec_splat_s16 (0); \ -+ shift = vec_splat_u16 (4); \ -+ \ -+ vx0 = vec_mradds (vec_sl (block[0], shift), constants[1], zero); \ -+ vx1 = vec_mradds (vec_sl (block[1], shift), constants[2], zero); \ -+ vx2 = vec_mradds (vec_sl (block[2], shift), constants[3], zero); \ -+ vx3 = vec_mradds (vec_sl (block[3], shift), constants[4], zero); \ -+ vx4 = vec_mradds (vec_sl (block[4], shift), constants[1], zero); \ -+ vx5 = vec_mradds (vec_sl (block[5], shift), constants[4], zero); \ -+ vx6 = vec_mradds (vec_sl (block[6], shift), constants[3], zero); \ -+ vx7 = vec_mradds (vec_sl (block[7], shift), constants[2], zero); \ -+ \ -+ IDCT_HALF \ -+ \ -+ vx0 = vec_mergeh (vy0, vy4); \ -+ vx1 = vec_mergel (vy0, vy4); \ -+ vx2 = vec_mergeh (vy1, vy5); \ -+ vx3 = vec_mergel (vy1, vy5); \ -+ vx4 = vec_mergeh (vy2, vy6); \ -+ vx5 = vec_mergel (vy2, vy6); \ -+ vx6 = vec_mergeh (vy3, vy7); \ -+ vx7 = vec_mergel (vy3, vy7); \ -+ \ -+ vy0 = vec_mergeh (vx0, vx4); \ -+ vy1 = vec_mergel (vx0, vx4); \ -+ vy2 = vec_mergeh (vx1, vx5); \ -+ vy3 = vec_mergel (vx1, vx5); \ -+ vy4 = vec_mergeh (vx2, vx6); \ -+ vy5 = vec_mergel (vx2, vx6); \ -+ vy6 = vec_mergeh (vx3, vx7); \ -+ vy7 = vec_mergel (vx3, vx7); \ -+ \ -+ vx0 = vec_adds (vec_mergeh (vy0, vy4), bias); \ -+ vx1 = vec_mergel (vy0, vy4); \ -+ vx2 = vec_mergeh (vy1, vy5); \ -+ vx3 = vec_mergel (vy1, vy5); \ -+ vx4 = vec_mergeh (vy2, vy6); \ -+ vx5 = vec_mergel (vy2, vy6); \ -+ vx6 = vec_mergeh (vy3, vy7); \ -+ vx7 = vec_mergel (vy3, vy7); \ -+ \ -+ IDCT_HALF \ -+ \ -+ shift = vec_splat_u16 (6); \ -+ vx0 = vec_sra (vy0, shift); \ -+ vx1 = vec_sra (vy1, shift); \ -+ vx2 = vec_sra (vy2, shift); \ -+ vx3 = vec_sra (vy3, shift); \ -+ vx4 = vec_sra (vy4, shift); \ -+ vx5 = vec_sra (vy5, shift); \ -+ vx6 = vec_sra (vy6, shift); \ -+ vx7 = vec_sra (vy7, shift); -+ -+ -+static const vector_s16_t constants[5] = { -+ (vector_s16_t) AVV(23170, 13573, 6518, 21895, -23170, -21895, 32, 31), -+ (vector_s16_t) AVV(16384, 22725, 21407, 19266, 16384, 19266, 21407, 22725), -+ (vector_s16_t) AVV(22725, 31521, 29692, 26722, 22725, 26722, 29692, 31521), -+ (vector_s16_t) AVV(21407, 29692, 27969, 25172, 21407, 25172, 27969, 29692), -+ (vector_s16_t) AVV(19266, 26722, 25172, 22654, 19266, 22654, 25172, 26722) -+}; -+ -+void idct_put_altivec(uint8_t* dest, int stride, vector_s16_t* block) -+{ -+POWERPC_PERF_DECLARE(altivec_idct_put_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+POWERPC_PERF_START_COUNT(altivec_idct_put_num, 1); -+ void simple_idct_put(uint8_t *dest, int line_size, int16_t *block); -+ simple_idct_put(dest, stride, (int16_t*)block); -+POWERPC_PERF_STOP_COUNT(altivec_idct_put_num, 1); -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ vector_u8_t tmp; -+ -+POWERPC_PERF_START_COUNT(altivec_idct_put_num, 1); -+ -+ IDCT -+ -+#define COPY(dest,src) \ -+ tmp = vec_packsu (src, src); \ -+ vec_ste ((vector_u32_t)tmp, 0, (unsigned int *)dest); \ -+ vec_ste ((vector_u32_t)tmp, 4, (unsigned int *)dest); -+ -+ COPY (dest, vx0) dest += stride; -+ COPY (dest, vx1) dest += stride; -+ COPY (dest, vx2) dest += stride; -+ COPY (dest, vx3) dest += stride; -+ COPY (dest, vx4) dest += stride; -+ COPY (dest, vx5) dest += stride; -+ COPY (dest, vx6) dest += stride; -+ COPY (dest, vx7) -+ -+POWERPC_PERF_STOP_COUNT(altivec_idct_put_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -+void idct_add_altivec(uint8_t* dest, int stride, vector_s16_t* block) -+{ -+POWERPC_PERF_DECLARE(altivec_idct_add_num, 1); -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+POWERPC_PERF_START_COUNT(altivec_idct_add_num, 1); -+ void simple_idct_add(uint8_t *dest, int line_size, int16_t *block); -+ simple_idct_add(dest, stride, (int16_t*)block); -+POWERPC_PERF_STOP_COUNT(altivec_idct_add_num, 1); -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ vector_u8_t tmp; -+ vector_s16_t tmp2, tmp3; -+ vector_u8_t perm0; -+ vector_u8_t perm1; -+ vector_u8_t p0, p1, p; -+ -+POWERPC_PERF_START_COUNT(altivec_idct_add_num, 1); -+ -+ IDCT -+ -+ p0 = vec_lvsl (0, dest); -+ p1 = vec_lvsl (stride, dest); -+ p = vec_splat_u8 (-1); -+ perm0 = vec_mergeh (p, p0); -+ perm1 = vec_mergeh (p, p1); -+ -+#define ADD(dest,src,perm) \ -+ /* *(uint64_t *)&tmp = *(uint64_t *)dest; */ \ -+ tmp = vec_ld (0, dest); \ -+ tmp2 = (vector_s16_t)vec_perm (tmp, (vector_u8_t)zero, perm); \ -+ tmp3 = vec_adds (tmp2, src); \ -+ tmp = vec_packsu (tmp3, tmp3); \ -+ vec_ste ((vector_u32_t)tmp, 0, (unsigned int *)dest); \ -+ vec_ste ((vector_u32_t)tmp, 4, (unsigned int *)dest); -+ -+ ADD (dest, vx0, perm0) dest += stride; -+ ADD (dest, vx1, perm1) dest += stride; -+ ADD (dest, vx2, perm0) dest += stride; -+ ADD (dest, vx3, perm1) dest += stride; -+ ADD (dest, vx4, perm0) dest += stride; -+ ADD (dest, vx5, perm1) dest += stride; -+ ADD (dest, vx6, perm0) dest += stride; -+ ADD (dest, vx7, perm1) -+ -+POWERPC_PERF_STOP_COUNT(altivec_idct_add_num, 1); -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+} -+ -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/mpegvideo_altivec.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/mpegvideo_altivec.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/mpegvideo_altivec.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/mpegvideo_altivec.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,645 @@ -+/* -+ * Copyright (c) 2002 Dieter Shirley -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include -+#include -+#include "../dsputil.h" -+#include "../mpegvideo.h" -+ -+#include "gcc_fixes.h" -+ -+#include "dsputil_altivec.h" -+ -+// Swaps two variables (used for altivec registers) -+#define SWAP(a,b) \ -+do { \ -+ __typeof__(a) swap_temp=a; \ -+ a=b; \ -+ b=swap_temp; \ -+} while (0) -+ -+// transposes a matrix consisting of four vectors with four elements each -+#define TRANSPOSE4(a,b,c,d) \ -+do { \ -+ __typeof__(a) _trans_ach = vec_mergeh(a, c); \ -+ __typeof__(a) _trans_acl = vec_mergel(a, c); \ -+ __typeof__(a) _trans_bdh = vec_mergeh(b, d); \ -+ __typeof__(a) _trans_bdl = vec_mergel(b, d); \ -+ \ -+ a = vec_mergeh(_trans_ach, _trans_bdh); \ -+ b = vec_mergel(_trans_ach, _trans_bdh); \ -+ c = vec_mergeh(_trans_acl, _trans_bdl); \ -+ d = vec_mergel(_trans_acl, _trans_bdl); \ -+} while (0) -+ -+#define TRANSPOSE8(a,b,c,d,e,f,g,h) \ -+do { \ -+ __typeof__(a) _A1, _B1, _C1, _D1, _E1, _F1, _G1, _H1; \ -+ __typeof__(a) _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) -+ -+ -+// Loads a four-byte value (int or float) from the target address -+// into every element in the target vector. Only works if the -+// target address is four-byte aligned (which should be always). -+#define LOAD4(vec, address) \ -+{ \ -+ __typeof__(vec)* _load_addr = (__typeof__(vec)*)(address); \ -+ vector unsigned char _perm_vec = vec_lvsl(0,(address)); \ -+ vec = vec_ld(0, _load_addr); \ -+ vec = vec_perm(vec, vec, _perm_vec); \ -+ vec = vec_splat(vec, 0); \ -+} -+ -+ -+#ifdef CONFIG_DARWIN -+#define FOUROF(a) (a) -+#else -+// slower, for dumb non-apple GCC -+#define FOUROF(a) {a,a,a,a} -+#endif -+int dct_quantize_altivec(MpegEncContext* s, -+ DCTELEM* data, int n, -+ int qscale, int* overflow) -+{ -+ int lastNonZero; -+ vector float row0, row1, row2, row3, row4, row5, row6, row7; -+ vector float alt0, alt1, alt2, alt3, alt4, alt5, alt6, alt7; -+ const vector float zero = (const vector float)FOUROF(0.); -+ -+ // Load the data into the row/alt vectors -+ { -+ vector signed short data0, data1, data2, data3, data4, data5, data6, data7; -+ -+ data0 = vec_ld(0, data); -+ data1 = vec_ld(16, data); -+ data2 = vec_ld(32, data); -+ data3 = vec_ld(48, data); -+ data4 = vec_ld(64, data); -+ data5 = vec_ld(80, data); -+ data6 = vec_ld(96, data); -+ data7 = vec_ld(112, data); -+ -+ // Transpose the data before we start -+ TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7); -+ -+ // load the data into floating point vectors. We load -+ // the high half of each row into the main row vectors -+ // and the low half into the alt vectors. -+ row0 = vec_ctf(vec_unpackh(data0), 0); -+ alt0 = vec_ctf(vec_unpackl(data0), 0); -+ row1 = vec_ctf(vec_unpackh(data1), 0); -+ alt1 = vec_ctf(vec_unpackl(data1), 0); -+ row2 = vec_ctf(vec_unpackh(data2), 0); -+ alt2 = vec_ctf(vec_unpackl(data2), 0); -+ row3 = vec_ctf(vec_unpackh(data3), 0); -+ alt3 = vec_ctf(vec_unpackl(data3), 0); -+ row4 = vec_ctf(vec_unpackh(data4), 0); -+ alt4 = vec_ctf(vec_unpackl(data4), 0); -+ row5 = vec_ctf(vec_unpackh(data5), 0); -+ alt5 = vec_ctf(vec_unpackl(data5), 0); -+ row6 = vec_ctf(vec_unpackh(data6), 0); -+ alt6 = vec_ctf(vec_unpackl(data6), 0); -+ row7 = vec_ctf(vec_unpackh(data7), 0); -+ alt7 = vec_ctf(vec_unpackl(data7), 0); -+ } -+ -+ // The following block could exist as a separate an altivec dct -+ // function. However, if we put it inline, the DCT data can remain -+ // in the vector local variables, as floats, which we'll use during the -+ // quantize step... -+ { -+ const vector float vec_0_298631336 = (vector float)FOUROF(0.298631336f); -+ const vector float vec_0_390180644 = (vector float)FOUROF(-0.390180644f); -+ const vector float vec_0_541196100 = (vector float)FOUROF(0.541196100f); -+ const vector float vec_0_765366865 = (vector float)FOUROF(0.765366865f); -+ const vector float vec_0_899976223 = (vector float)FOUROF(-0.899976223f); -+ const vector float vec_1_175875602 = (vector float)FOUROF(1.175875602f); -+ const vector float vec_1_501321110 = (vector float)FOUROF(1.501321110f); -+ const vector float vec_1_847759065 = (vector float)FOUROF(-1.847759065f); -+ const vector float vec_1_961570560 = (vector float)FOUROF(-1.961570560f); -+ const vector float vec_2_053119869 = (vector float)FOUROF(2.053119869f); -+ const vector float vec_2_562915447 = (vector float)FOUROF(-2.562915447f); -+ const vector float vec_3_072711026 = (vector float)FOUROF(3.072711026f); -+ -+ -+ int whichPass, whichHalf; -+ -+ for(whichPass = 1; whichPass<=2; whichPass++) -+ { -+ for(whichHalf = 1; whichHalf<=2; whichHalf++) -+ { -+ vector float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; -+ vector float tmp10, tmp11, tmp12, tmp13; -+ vector float z1, z2, z3, z4, z5; -+ -+ tmp0 = vec_add(row0, row7); // tmp0 = dataptr[0] + dataptr[7]; -+ tmp7 = vec_sub(row0, row7); // tmp7 = dataptr[0] - dataptr[7]; -+ tmp3 = vec_add(row3, row4); // tmp3 = dataptr[3] + dataptr[4]; -+ tmp4 = vec_sub(row3, row4); // tmp4 = dataptr[3] - dataptr[4]; -+ tmp1 = vec_add(row1, row6); // tmp1 = dataptr[1] + dataptr[6]; -+ tmp6 = vec_sub(row1, row6); // tmp6 = dataptr[1] - dataptr[6]; -+ tmp2 = vec_add(row2, row5); // tmp2 = dataptr[2] + dataptr[5]; -+ tmp5 = vec_sub(row2, row5); // tmp5 = dataptr[2] - dataptr[5]; -+ -+ tmp10 = vec_add(tmp0, tmp3); // tmp10 = tmp0 + tmp3; -+ tmp13 = vec_sub(tmp0, tmp3); // tmp13 = tmp0 - tmp3; -+ tmp11 = vec_add(tmp1, tmp2); // tmp11 = tmp1 + tmp2; -+ tmp12 = vec_sub(tmp1, tmp2); // tmp12 = tmp1 - tmp2; -+ -+ -+ // dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS); -+ row0 = vec_add(tmp10, tmp11); -+ -+ // dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS); -+ row4 = vec_sub(tmp10, tmp11); -+ -+ -+ // z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); -+ z1 = vec_madd(vec_add(tmp12, tmp13), vec_0_541196100, (vector float)zero); -+ -+ // dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865), -+ // CONST_BITS-PASS1_BITS); -+ row2 = vec_madd(tmp13, vec_0_765366865, z1); -+ -+ // dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065), -+ // CONST_BITS-PASS1_BITS); -+ row6 = vec_madd(tmp12, vec_1_847759065, z1); -+ -+ z1 = vec_add(tmp4, tmp7); // z1 = tmp4 + tmp7; -+ z2 = vec_add(tmp5, tmp6); // z2 = tmp5 + tmp6; -+ z3 = vec_add(tmp4, tmp6); // z3 = tmp4 + tmp6; -+ z4 = vec_add(tmp5, tmp7); // z4 = tmp5 + tmp7; -+ -+ // z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ -+ z5 = vec_madd(vec_add(z3, z4), vec_1_175875602, (vector float)zero); -+ -+ // z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ -+ z3 = vec_madd(z3, vec_1_961570560, z5); -+ -+ // z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ -+ z4 = vec_madd(z4, vec_0_390180644, z5); -+ -+ // The following adds are rolled into the multiplies above -+ // z3 = vec_add(z3, z5); // z3 += z5; -+ // z4 = vec_add(z4, z5); // z4 += z5; -+ -+ // z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ -+ // Wow! It's actually more effecient to roll this multiply -+ // into the adds below, even thought the multiply gets done twice! -+ // z2 = vec_madd(z2, vec_2_562915447, (vector float)zero); -+ -+ // z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ -+ // Same with this one... -+ // z1 = vec_madd(z1, vec_0_899976223, (vector float)zero); -+ -+ // tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ -+ // dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS); -+ row7 = vec_madd(tmp4, vec_0_298631336, vec_madd(z1, vec_0_899976223, z3)); -+ -+ // tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ -+ // dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS); -+ row5 = vec_madd(tmp5, vec_2_053119869, vec_madd(z2, vec_2_562915447, z4)); -+ -+ // tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ -+ // dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS); -+ row3 = vec_madd(tmp6, vec_3_072711026, vec_madd(z2, vec_2_562915447, z3)); -+ -+ // tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ -+ // dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS); -+ row1 = vec_madd(z1, vec_0_899976223, vec_madd(tmp7, vec_1_501321110, z4)); -+ -+ // Swap the row values with the alts. If this is the first half, -+ // this sets up the low values to be acted on in the second half. -+ // If this is the second half, it puts the high values back in -+ // the row values where they are expected to be when we're done. -+ SWAP(row0, alt0); -+ SWAP(row1, alt1); -+ SWAP(row2, alt2); -+ SWAP(row3, alt3); -+ SWAP(row4, alt4); -+ SWAP(row5, alt5); -+ SWAP(row6, alt6); -+ SWAP(row7, alt7); -+ } -+ -+ if (whichPass == 1) -+ { -+ // transpose the data for the second pass -+ -+ // First, block transpose the upper right with lower left. -+ SWAP(row4, alt0); -+ SWAP(row5, alt1); -+ SWAP(row6, alt2); -+ SWAP(row7, alt3); -+ -+ // Now, transpose each block of four -+ TRANSPOSE4(row0, row1, row2, row3); -+ TRANSPOSE4(row4, row5, row6, row7); -+ TRANSPOSE4(alt0, alt1, alt2, alt3); -+ TRANSPOSE4(alt4, alt5, alt6, alt7); -+ } -+ } -+ } -+ -+ // used after quantise step -+ int oldBaseValue = 0; -+ -+ // perform the quantise step, using the floating point data -+ // still in the row/alt registers -+ { -+ const int* biasAddr; -+ const vector signed int* qmat; -+ vector float bias, negBias; -+ -+ if (s->mb_intra) -+ { -+ vector signed int baseVector; -+ -+ // We must cache element 0 in the intra case -+ // (it needs special handling). -+ baseVector = vec_cts(vec_splat(row0, 0), 0); -+ vec_ste(baseVector, 0, &oldBaseValue); -+ -+ qmat = (vector signed int*)s->q_intra_matrix[qscale]; -+ biasAddr = &(s->intra_quant_bias); -+ } -+ else -+ { -+ qmat = (vector signed int*)s->q_inter_matrix[qscale]; -+ biasAddr = &(s->inter_quant_bias); -+ } -+ -+ // Load the bias vector (We add 0.5 to the bias so that we're -+ // rounding when we convert to int, instead of flooring.) -+ { -+ vector signed int biasInt; -+ const vector float negOneFloat = (vector float)FOUROF(-1.0f); -+ LOAD4(biasInt, biasAddr); -+ bias = vec_ctf(biasInt, QUANT_BIAS_SHIFT); -+ negBias = vec_madd(bias, negOneFloat, zero); -+ } -+ -+ { -+ vector float q0, q1, q2, q3, q4, q5, q6, q7; -+ -+ q0 = vec_ctf(qmat[0], QMAT_SHIFT); -+ q1 = vec_ctf(qmat[2], QMAT_SHIFT); -+ q2 = vec_ctf(qmat[4], QMAT_SHIFT); -+ q3 = vec_ctf(qmat[6], QMAT_SHIFT); -+ q4 = vec_ctf(qmat[8], QMAT_SHIFT); -+ q5 = vec_ctf(qmat[10], QMAT_SHIFT); -+ q6 = vec_ctf(qmat[12], QMAT_SHIFT); -+ q7 = vec_ctf(qmat[14], QMAT_SHIFT); -+ -+ row0 = vec_sel(vec_madd(row0, q0, negBias), vec_madd(row0, q0, bias), -+ vec_cmpgt(row0, zero)); -+ row1 = vec_sel(vec_madd(row1, q1, negBias), vec_madd(row1, q1, bias), -+ vec_cmpgt(row1, zero)); -+ row2 = vec_sel(vec_madd(row2, q2, negBias), vec_madd(row2, q2, bias), -+ vec_cmpgt(row2, zero)); -+ row3 = vec_sel(vec_madd(row3, q3, negBias), vec_madd(row3, q3, bias), -+ vec_cmpgt(row3, zero)); -+ row4 = vec_sel(vec_madd(row4, q4, negBias), vec_madd(row4, q4, bias), -+ vec_cmpgt(row4, zero)); -+ row5 = vec_sel(vec_madd(row5, q5, negBias), vec_madd(row5, q5, bias), -+ vec_cmpgt(row5, zero)); -+ row6 = vec_sel(vec_madd(row6, q6, negBias), vec_madd(row6, q6, bias), -+ vec_cmpgt(row6, zero)); -+ row7 = vec_sel(vec_madd(row7, q7, negBias), vec_madd(row7, q7, bias), -+ vec_cmpgt(row7, zero)); -+ -+ q0 = vec_ctf(qmat[1], QMAT_SHIFT); -+ q1 = vec_ctf(qmat[3], QMAT_SHIFT); -+ q2 = vec_ctf(qmat[5], QMAT_SHIFT); -+ q3 = vec_ctf(qmat[7], QMAT_SHIFT); -+ q4 = vec_ctf(qmat[9], QMAT_SHIFT); -+ q5 = vec_ctf(qmat[11], QMAT_SHIFT); -+ q6 = vec_ctf(qmat[13], QMAT_SHIFT); -+ q7 = vec_ctf(qmat[15], QMAT_SHIFT); -+ -+ alt0 = vec_sel(vec_madd(alt0, q0, negBias), vec_madd(alt0, q0, bias), -+ vec_cmpgt(alt0, zero)); -+ alt1 = vec_sel(vec_madd(alt1, q1, negBias), vec_madd(alt1, q1, bias), -+ vec_cmpgt(alt1, zero)); -+ alt2 = vec_sel(vec_madd(alt2, q2, negBias), vec_madd(alt2, q2, bias), -+ vec_cmpgt(alt2, zero)); -+ alt3 = vec_sel(vec_madd(alt3, q3, negBias), vec_madd(alt3, q3, bias), -+ vec_cmpgt(alt3, zero)); -+ alt4 = vec_sel(vec_madd(alt4, q4, negBias), vec_madd(alt4, q4, bias), -+ vec_cmpgt(alt4, zero)); -+ alt5 = vec_sel(vec_madd(alt5, q5, negBias), vec_madd(alt5, q5, bias), -+ vec_cmpgt(alt5, zero)); -+ alt6 = vec_sel(vec_madd(alt6, q6, negBias), vec_madd(alt6, q6, bias), -+ vec_cmpgt(alt6, zero)); -+ alt7 = vec_sel(vec_madd(alt7, q7, negBias), vec_madd(alt7, q7, bias), -+ vec_cmpgt(alt7, zero)); -+ } -+ -+ -+ } -+ -+ // Store the data back into the original block -+ { -+ vector signed short data0, data1, data2, data3, data4, data5, data6, data7; -+ -+ data0 = vec_pack(vec_cts(row0, 0), vec_cts(alt0, 0)); -+ data1 = vec_pack(vec_cts(row1, 0), vec_cts(alt1, 0)); -+ data2 = vec_pack(vec_cts(row2, 0), vec_cts(alt2, 0)); -+ data3 = vec_pack(vec_cts(row3, 0), vec_cts(alt3, 0)); -+ data4 = vec_pack(vec_cts(row4, 0), vec_cts(alt4, 0)); -+ data5 = vec_pack(vec_cts(row5, 0), vec_cts(alt5, 0)); -+ data6 = vec_pack(vec_cts(row6, 0), vec_cts(alt6, 0)); -+ data7 = vec_pack(vec_cts(row7, 0), vec_cts(alt7, 0)); -+ -+ { -+ // Clamp for overflow -+ vector signed int max_q_int, min_q_int; -+ vector signed short max_q, min_q; -+ -+ LOAD4(max_q_int, &(s->max_qcoeff)); -+ LOAD4(min_q_int, &(s->min_qcoeff)); -+ -+ max_q = vec_pack(max_q_int, max_q_int); -+ min_q = vec_pack(min_q_int, min_q_int); -+ -+ data0 = vec_max(vec_min(data0, max_q), min_q); -+ data1 = vec_max(vec_min(data1, max_q), min_q); -+ data2 = vec_max(vec_min(data2, max_q), min_q); -+ data4 = vec_max(vec_min(data4, max_q), min_q); -+ data5 = vec_max(vec_min(data5, max_q), min_q); -+ data6 = vec_max(vec_min(data6, max_q), min_q); -+ data7 = vec_max(vec_min(data7, max_q), min_q); -+ } -+ -+ vector bool char zero_01, zero_23, zero_45, zero_67; -+ vector signed char scanIndices_01, scanIndices_23, scanIndices_45, scanIndices_67; -+ vector signed char negOne = vec_splat_s8(-1); -+ vector signed char* scanPtr = -+ (vector signed char*)(s->intra_scantable.inverse); -+ -+ // Determine the largest non-zero index. -+ zero_01 = vec_pack(vec_cmpeq(data0, (vector short)zero), -+ vec_cmpeq(data1, (vector short)zero)); -+ zero_23 = vec_pack(vec_cmpeq(data2, (vector short)zero), -+ vec_cmpeq(data3, (vector short)zero)); -+ zero_45 = vec_pack(vec_cmpeq(data4, (vector short)zero), -+ vec_cmpeq(data5, (vector short)zero)); -+ zero_67 = vec_pack(vec_cmpeq(data6, (vector short)zero), -+ vec_cmpeq(data7, (vector short)zero)); -+ -+ // 64 biggest values -+ scanIndices_01 = vec_sel(scanPtr[0], negOne, zero_01); -+ scanIndices_23 = vec_sel(scanPtr[1], negOne, zero_23); -+ scanIndices_45 = vec_sel(scanPtr[2], negOne, zero_45); -+ scanIndices_67 = vec_sel(scanPtr[3], negOne, zero_67); -+ -+ // 32 largest values -+ scanIndices_01 = vec_max(scanIndices_01, scanIndices_23); -+ scanIndices_45 = vec_max(scanIndices_45, scanIndices_67); -+ -+ // 16 largest values -+ scanIndices_01 = vec_max(scanIndices_01, scanIndices_45); -+ -+ // 8 largest values -+ scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne), -+ vec_mergel(scanIndices_01, negOne)); -+ -+ // 4 largest values -+ scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne), -+ vec_mergel(scanIndices_01, negOne)); -+ -+ // 2 largest values -+ scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne), -+ vec_mergel(scanIndices_01, negOne)); -+ -+ // largest value -+ scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne), -+ vec_mergel(scanIndices_01, negOne)); -+ -+ scanIndices_01 = vec_splat(scanIndices_01, 0); -+ -+ signed char lastNonZeroChar; -+ -+ vec_ste(scanIndices_01, 0, &lastNonZeroChar); -+ -+ lastNonZero = lastNonZeroChar; -+ -+ // While the data is still in vectors we check for the transpose IDCT permute -+ // and handle it using the vector unit if we can. This is the permute used -+ // by the altivec idct, so it is common when using the altivec dct. -+ -+ if ((lastNonZero > 0) && (s->dsp.idct_permutation_type == FF_TRANSPOSE_IDCT_PERM)) -+ { -+ TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7); -+ } -+ -+ vec_st(data0, 0, data); -+ vec_st(data1, 16, data); -+ vec_st(data2, 32, data); -+ vec_st(data3, 48, data); -+ vec_st(data4, 64, data); -+ vec_st(data5, 80, data); -+ vec_st(data6, 96, data); -+ vec_st(data7, 112, data); -+ } -+ -+ // special handling of block[0] -+ if (s->mb_intra) -+ { -+ if (!s->h263_aic) -+ { -+ if (n < 4) -+ oldBaseValue /= s->y_dc_scale; -+ else -+ oldBaseValue /= s->c_dc_scale; -+ } -+ -+ // Divide by 8, rounding the result -+ data[0] = (oldBaseValue + 4) >> 3; -+ } -+ -+ // We handled the tranpose permutation above and we don't -+ // need to permute the "no" permutation case. -+ if ((lastNonZero > 0) && -+ (s->dsp.idct_permutation_type != FF_TRANSPOSE_IDCT_PERM) && -+ (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)) -+ { -+ ff_block_permute(data, s->dsp.idct_permutation, -+ s->intra_scantable.scantable, lastNonZero); -+ } -+ -+ return lastNonZero; -+} -+#undef FOUROF -+ -+/* -+ AltiVec version of dct_unquantize_h263 -+ this code assumes `block' is 16 bytes-aligned -+*/ -+void dct_unquantize_h263_altivec(MpegEncContext *s, -+ DCTELEM *block, int n, int qscale) -+{ -+POWERPC_PERF_DECLARE(altivec_dct_unquantize_h263_num, 1); -+ int i, level, qmul, qadd; -+ int nCoeffs; -+ -+ assert(s->block_last_index[n]>=0); -+ -+POWERPC_PERF_START_COUNT(altivec_dct_unquantize_h263_num, 1); -+ -+ qadd = (qscale - 1) | 1; -+ qmul = qscale << 1; -+ -+ if (s->mb_intra) { -+ if (!s->h263_aic) { -+ if (n < 4) -+ block[0] = block[0] * s->y_dc_scale; -+ else -+ block[0] = block[0] * s->c_dc_scale; -+ }else -+ qadd = 0; -+ i = 1; -+ nCoeffs= 63; //does not allways use zigzag table -+ } else { -+ i = 0; -+ nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ]; -+ } -+ -+#ifdef ALTIVEC_USE_REFERENCE_C_CODE -+ for(;i<=nCoeffs;i++) { -+ level = block[i]; -+ if (level) { -+ if (level < 0) { -+ level = level * qmul - qadd; -+ } else { -+ level = level * qmul + qadd; -+ } -+ block[i] = level; -+ } -+ } -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ { -+ register const vector short vczero = (const vector short)vec_splat_s16(0); -+ short __attribute__ ((aligned(16))) qmul8[] = -+ { -+ qmul, qmul, qmul, qmul, -+ qmul, qmul, qmul, qmul -+ }; -+ short __attribute__ ((aligned(16))) qadd8[] = -+ { -+ qadd, qadd, qadd, qadd, -+ qadd, qadd, qadd, qadd -+ }; -+ short __attribute__ ((aligned(16))) nqadd8[] = -+ { -+ -qadd, -qadd, -qadd, -qadd, -+ -qadd, -qadd, -qadd, -qadd -+ }; -+ register vector short blockv, qmulv, qaddv, nqaddv, temp1; -+ register vector bool short blockv_null, blockv_neg; -+ register short backup_0 = block[0]; -+ register int j = 0; -+ -+ qmulv = vec_ld(0, qmul8); -+ qaddv = vec_ld(0, qadd8); -+ nqaddv = vec_ld(0, nqadd8); -+ -+#if 0 // block *is* 16 bytes-aligned, it seems. -+ // first make sure block[j] is 16 bytes-aligned -+ for(j = 0; (j <= nCoeffs) && ((((unsigned long)block) + (j << 1)) & 0x0000000F) ; j++) { -+ level = block[j]; -+ if (level) { -+ if (level < 0) { -+ level = level * qmul - qadd; -+ } else { -+ level = level * qmul + qadd; -+ } -+ block[j] = level; -+ } -+ } -+#endif -+ -+ // vectorize all the 16 bytes-aligned blocks -+ // of 8 elements -+ for(; (j + 7) <= nCoeffs ; j+=8) -+ { -+ blockv = vec_ld(j << 1, block); -+ blockv_neg = vec_cmplt(blockv, vczero); -+ blockv_null = vec_cmpeq(blockv, vczero); -+ // choose between +qadd or -qadd as the third operand -+ temp1 = vec_sel(qaddv, nqaddv, blockv_neg); -+ // multiply & add (block{i,i+7} * qmul [+-] qadd) -+ temp1 = vec_mladd(blockv, qmulv, temp1); -+ // put 0 where block[{i,i+7} used to have 0 -+ blockv = vec_sel(temp1, blockv, blockv_null); -+ vec_st(blockv, j << 1, block); -+ } -+ -+ // if nCoeffs isn't a multiple of 8, finish the job -+ // using good old scalar units. -+ // (we could do it using a truncated vector, -+ // but I'm not sure it's worth the hassle) -+ for(; j <= nCoeffs ; j++) { -+ level = block[j]; -+ if (level) { -+ if (level < 0) { -+ level = level * qmul - qadd; -+ } else { -+ level = level * qmul + qadd; -+ } -+ block[j] = level; -+ } -+ } -+ -+ if (i == 1) -+ { // cheat. this avoid special-casing the first iteration -+ block[0] = backup_0; -+ } -+ } -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ -+POWERPC_PERF_STOP_COUNT(altivec_dct_unquantize_h263_num, nCoeffs == 63); -+} -diff -Nur avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/mpegvideo_ppc.c avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/mpegvideo_ppc.c ---- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc.orig/mpegvideo_ppc.c 1970-01-01 01:00:00.000000000 +0100 -+++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/mpegvideo_ppc.c 2003-09-28 17:26:40.000000000 +0200 -@@ -0,0 +1,83 @@ -+/* -+ * Copyright (c) 2002 Dieter Shirley -+ * -+ * This library 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 of the License, or (at your option) any later version. -+ * -+ * This library 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 this library; if not, write to the Free Software -+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#include "../dsputil.h" -+#include "../mpegvideo.h" -+#include -+ -+#ifdef HAVE_ALTIVEC -+#include "dsputil_altivec.h" -+#endif -+ -+extern int dct_quantize_altivec(MpegEncContext *s, -+ DCTELEM *block, int n, -+ int qscale, int *overflow); -+extern void dct_unquantize_h263_altivec(MpegEncContext *s, -+ DCTELEM *block, int n, int qscale); -+ -+extern void idct_put_altivec(uint8_t *dest, int line_size, int16_t *block); -+extern void idct_add_altivec(uint8_t *dest, int line_size, int16_t *block); -+ -+ -+void MPV_common_init_ppc(MpegEncContext *s) -+{ -+#if HAVE_ALTIVEC -+ if (has_altivec()) -+ { -+ if ((s->avctx->idct_algo == FF_IDCT_AUTO) || -+ (s->avctx->idct_algo == FF_IDCT_ALTIVEC)) -+ { -+ s->dsp.idct_put = idct_put_altivec; -+ s->dsp.idct_add = idct_add_altivec; -+#ifndef ALTIVEC_USE_REFERENCE_C_CODE -+ s->dsp.idct_permutation_type = FF_TRANSPOSE_IDCT_PERM; -+#else /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ s->dsp.idct_permutation_type = FF_NO_IDCT_PERM; -+#endif /* ALTIVEC_USE_REFERENCE_C_CODE */ -+ } -+ -+ // Test to make sure that the dct required alignments are met. -+ if ((((long)(s->q_intra_matrix) & 0x0f) != 0) || -+ (((long)(s->q_inter_matrix) & 0x0f) != 0)) -+ { -+ fprintf(stderr, "Internal Error: q-matrix blocks must be 16-byte aligned " -+ "to use Altivec DCT. Reverting to non-altivec version.\n"); -+ return; -+ } -+ -+ if (((long)(s->intra_scantable.inverse) & 0x0f) != 0) -+ { -+ fprintf(stderr, "Internal Error: scan table blocks must be 16-byte aligned " -+ "to use Altivec DCT. Reverting to non-altivec version.\n"); -+ return; -+ } -+ -+ -+ if ((s->avctx->dct_algo == FF_DCT_AUTO) || -+ (s->avctx->dct_algo == FF_DCT_ALTIVEC)) -+ { -+ s->dct_quantize = dct_quantize_altivec; -+ s->dct_unquantize_h263 = dct_unquantize_h263_altivec; -+ } -+ } else -+#endif -+ { -+ /* Non-AltiVec PPC optimisations here */ -+ } -+} -+ --- avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/Makefile.am.orig 2003-05-25 23:11:57.000000000 +0200 +++ avifile-0.7-0.7.38/ffmpeg/libavcodec/ppc/Makefile.am 2003-11-14 01:06:03.904622008 +0100 @@ -20,6 +20,6 @@ -- 2.44.0