/*
* Copyright (c) 2002 Dieter Shirley
*
- * This library is free software; you can redistribute it and/or
+ * dct_unquantize_h263_altivec:
+ * Copyright (c) 2003 Romain Dolbeau <romain@dolbeau.org>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-
+
#include <stdlib.h>
#include <stdio.h>
-#include "../dsputil.h"
-#include "../mpegvideo.h"
+#include "libavutil/cpu.h"
+#include "libavcodec/dsputil.h"
+#include "libavcodec/mpegvideo.h"
+
+#include "util_altivec.h"
+#include "types_altivec.h"
#include "dsputil_altivec.h"
// Swaps two variables (used for altivec registers)
// 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); \
+ __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)
// 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); \
+ __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); \
}
-int dct_quantize_altivec(MpegEncContext* s,
- DCTELEM* data, int n,
- int qscale, int* overflow)
+
+#define FOUROF(a) {a,a,a,a}
+
+static 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)(0.0f);
+ const vector float zero = (const vector float)FOUROF(0.);
+ // used after quantize step
+ int oldBaseValue = 0;
// Load the data into the row/alt vectors
{
}
// 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...
+ // 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)(0.298631336f);
- const vector float vec_0_390180644 = (vector float)(-0.390180644f);
- const vector float vec_0_541196100 = (vector float)(0.541196100f);
- const vector float vec_0_765366865 = (vector float)(0.765366865f);
- const vector float vec_0_899976223 = (vector float)(-0.899976223f);
- const vector float vec_1_175875602 = (vector float)(1.175875602f);
- const vector float vec_1_501321110 = (vector float)(1.501321110f);
- const vector float vec_1_847759065 = (vector float)(-1.847759065f);
- const vector float vec_1_961570560 = (vector float)(-1.961570560f);
- const vector float vec_2_053119869 = (vector float)(2.053119869f);
- const vector float vec_2_562915447 = (vector float)(-2.562915447f);
- const vector float vec_3_072711026 = (vector float)(3.072711026f);
+ 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++)
- {
+ 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;
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);
+ // 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);
+ // CONST_BITS-PASS1_BITS);
row6 = vec_madd(tmp12, vec_1_847759065, z1);
z1 = vec_add(tmp4, tmp7); // z1 = tmp4 + tmp7;
// 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
+ // Wow! It's actually more efficient 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);
SWAP(row7, alt7);
}
- if (whichPass == 1)
- {
+ 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);
}
}
- // used after quantise step
- int oldBaseValue = 0;
-
- // perform the quantise step, using the floating point data
+ // perform the quantize 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)
- {
+ if (s->mb_intra) {
vector signed int baseVector;
// We must cache element 0 in the intra case
qmat = (vector signed int*)s->q_intra_matrix[qscale];
biasAddr = &(s->intra_quant_bias);
- }
- else
- {
+ } 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.)
+ // rounding when we convert to int, instead of flooring.)
{
vector signed int biasInt;
- const vector float negOneFloat = (vector float)(-1.0f);
+ 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);
vec_cmpgt(alt7, zero));
}
-
+
}
// Store the data back into the original block
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 scanIndexes_01, scanIndexes_23, scanIndexes_45, scanIndexes_67;
vector signed char negOne = vec_splat_s8(-1);
vector signed char* scanPtr =
(vector signed char*)(s->intra_scantable.inverse);
+ signed char lastNonZeroChar;
// 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));
+ zero_01 = vec_pack(vec_cmpeq(data0, (vector signed short)zero),
+ vec_cmpeq(data1, (vector signed short)zero));
+ zero_23 = vec_pack(vec_cmpeq(data2, (vector signed short)zero),
+ vec_cmpeq(data3, (vector signed short)zero));
+ zero_45 = vec_pack(vec_cmpeq(data4, (vector signed short)zero),
+ vec_cmpeq(data5, (vector signed short)zero));
+ zero_67 = vec_pack(vec_cmpeq(data6, (vector signed short)zero),
+ vec_cmpeq(data7, (vector signed 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);
+ scanIndexes_01 = vec_sel(scanPtr[0], negOne, zero_01);
+ scanIndexes_23 = vec_sel(scanPtr[1], negOne, zero_23);
+ scanIndexes_45 = vec_sel(scanPtr[2], negOne, zero_45);
+ scanIndexes_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);
+ scanIndexes_01 = vec_max(scanIndexes_01, scanIndexes_23);
+ scanIndexes_45 = vec_max(scanIndexes_45, scanIndexes_67);
// 16 largest values
- scanIndices_01 = vec_max(scanIndices_01, scanIndices_45);
+ scanIndexes_01 = vec_max(scanIndexes_01, scanIndexes_45);
// 8 largest values
- scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
- vec_mergel(scanIndices_01, negOne));
+ scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
+ vec_mergel(scanIndexes_01, negOne));
// 4 largest values
- scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
- vec_mergel(scanIndices_01, negOne));
+ scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
+ vec_mergel(scanIndexes_01, negOne));
// 2 largest values
- scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
- vec_mergel(scanIndices_01, negOne));
+ scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
+ vec_mergel(scanIndexes_01, negOne));
// largest value
- scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
- vec_mergel(scanIndices_01, negOne));
+ scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
+ vec_mergel(scanIndexes_01, negOne));
- scanIndices_01 = vec_splat(scanIndices_01, 0);
+ scanIndexes_01 = vec_splat(scanIndexes_01, 0);
- signed char lastNonZeroChar;
- vec_ste(scanIndices_01, 0, &lastNonZeroChar);
+ vec_ste(scanIndexes_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->idct_permutation_type == FF_TRANSPOSE_IDCT_PERM))
- {
+ if ((lastNonZero > 0) && (s->dsp.idct_permutation_type == FF_TRANSPOSE_IDCT_PERM)) {
TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7);
}
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 (s->mb_intra) {
+ if (!s->h263_aic) {
if (n < 4)
oldBaseValue /= s->y_dc_scale;
else
data[0] = (oldBaseValue + 4) >> 3;
}
- // We handled the tranpose permutation above and we don't
+ // We handled the transpose permutation above and we don't
// need to permute the "no" permutation case.
if ((lastNonZero > 0) &&
- (s->idct_permutation_type != FF_TRANSPOSE_IDCT_PERM) &&
- (s->idct_permutation_type != FF_NO_IDCT_PERM))
- {
- ff_block_permute(data, s->idct_permutation,
+ (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;
}
-/*
- AltiVec version of dct_unquantize_h263
- this code assumes `block' is 16 bytes-aligned
-*/
-void dct_unquantize_h263_altivec(MpegEncContext *s,
+/* AltiVec version of dct_unquantize_h263
+ this code assumes `block' is 16 bytes-aligned */
+static void dct_unquantize_h263_altivec(MpegEncContext *s,
DCTELEM *block, int n, int qscale)
{
-ALTIVEC_TBL_DECLARE(altivec_dct_unquantize_h263_num, 1);
int i, level, qmul, qadd;
int nCoeffs;
-
+
assert(s->block_last_index[n]>=0);
-ALTIVEC_TBL_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)
+ 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
+ nCoeffs= 63; //does not always 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)(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;
+ register const vector signed short vczero = (const vector signed short)vec_splat_s16(0);
+ DECLARE_ALIGNED(16, short, qmul8) = qmul;
+ DECLARE_ALIGNED(16, short, qadd8) = qadd;
+ register vector signed 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_splat((vec_s16)vec_lde(0, &qmul8), 0);
+ qaddv = vec_splat((vec_s16)vec_lde(0, &qadd8), 0);
+ nqaddv = vec_sub(vczero, qaddv);
+
+#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;
}
- 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;
+
+ // 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;
}
- block[j] = level;
}
- }
-
- if (i == 1)
- { // cheat. this avoid special-casing the first iteration
- block[0] = backup_0;
- }
+
+ if (i == 1) {
+ // cheat. this avoid special-casing the first iteration
+ block[0] = backup_0;
+ }
}
-#endif /* ALTIVEC_USE_REFERENCE_C_CODE */
+}
+
-ALTIVEC_TBL_STOP_COUNT(altivec_dct_unquantize_h263_num, nCoeffs == 63);
+void MPV_common_init_altivec(MpegEncContext *s)
+{
+ if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC)) return;
+
+ if (s->avctx->lowres==0) {
+ 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;
+ s->dsp.idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
+ }
+ }
+
+ // 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)) {
+ av_log(s->avctx, AV_LOG_INFO, "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) {
+ av_log(s->avctx, AV_LOG_INFO, "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)) {
+#if 0 /* seems to cause trouble under some circumstances */
+ s->dct_quantize = dct_quantize_altivec;
+#endif
+ s->dct_unquantize_h263_intra = dct_unquantize_h263_altivec;
+ s->dct_unquantize_h263_inter = dct_unquantize_h263_altivec;
+ }
}
projects / ffmpeg / blobdiff