00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <stdlib.h>
00025 #include <stdio.h>
00026 #include "dsputil.h"
00027 #include "mpegvideo.h"
00028
00029 #include "gcc_fixes.h"
00030
00031 #include "dsputil_ppc.h"
00032 #include "util_altivec.h"
00033
00034 #define SWAP(a,b) \
00035 do { \
00036 __typeof__(a) swap_temp=a; \
00037 a=b; \
00038 b=swap_temp; \
00039 } while (0)
00040
00041
00042 #define TRANSPOSE4(a,b,c,d) \
00043 do { \
00044 __typeof__(a) _trans_ach = vec_mergeh(a, c); \
00045 __typeof__(a) _trans_acl = vec_mergel(a, c); \
00046 __typeof__(a) _trans_bdh = vec_mergeh(b, d); \
00047 __typeof__(a) _trans_bdl = vec_mergel(b, d); \
00048 \
00049 a = vec_mergeh(_trans_ach, _trans_bdh); \
00050 b = vec_mergel(_trans_ach, _trans_bdh); \
00051 c = vec_mergeh(_trans_acl, _trans_bdl); \
00052 d = vec_mergel(_trans_acl, _trans_bdl); \
00053 } while (0)
00054
00055
00056
00057
00058
00059 #define LOAD4(vec, address) \
00060 { \
00061 __typeof__(vec)* _load_addr = (__typeof__(vec)*)(address); \
00062 vector unsigned char _perm_vec = vec_lvsl(0,(address)); \
00063 vec = vec_ld(0, _load_addr); \
00064 vec = vec_perm(vec, vec, _perm_vec); \
00065 vec = vec_splat(vec, 0); \
00066 }
00067
00068
00069 #ifdef __APPLE_CC__
00070 #define FOUROF(a) (a)
00071 #else
00072
00073 #define FOUROF(a) {a,a,a,a}
00074 #endif
00075 int dct_quantize_altivec(MpegEncContext* s,
00076 DCTELEM* data, int n,
00077 int qscale, int* overflow)
00078 {
00079 int lastNonZero;
00080 vector float row0, row1, row2, row3, row4, row5, row6, row7;
00081 vector float alt0, alt1, alt2, alt3, alt4, alt5, alt6, alt7;
00082 const vector float zero = (const vector float)FOUROF(0.);
00083
00084 int oldBaseValue = 0;
00085
00086
00087 {
00088 vector signed short data0, data1, data2, data3, data4, data5, data6, data7;
00089
00090 data0 = vec_ld(0, data);
00091 data1 = vec_ld(16, data);
00092 data2 = vec_ld(32, data);
00093 data3 = vec_ld(48, data);
00094 data4 = vec_ld(64, data);
00095 data5 = vec_ld(80, data);
00096 data6 = vec_ld(96, data);
00097 data7 = vec_ld(112, data);
00098
00099
00100 TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7);
00101
00102
00103
00104
00105 row0 = vec_ctf(vec_unpackh(data0), 0);
00106 alt0 = vec_ctf(vec_unpackl(data0), 0);
00107 row1 = vec_ctf(vec_unpackh(data1), 0);
00108 alt1 = vec_ctf(vec_unpackl(data1), 0);
00109 row2 = vec_ctf(vec_unpackh(data2), 0);
00110 alt2 = vec_ctf(vec_unpackl(data2), 0);
00111 row3 = vec_ctf(vec_unpackh(data3), 0);
00112 alt3 = vec_ctf(vec_unpackl(data3), 0);
00113 row4 = vec_ctf(vec_unpackh(data4), 0);
00114 alt4 = vec_ctf(vec_unpackl(data4), 0);
00115 row5 = vec_ctf(vec_unpackh(data5), 0);
00116 alt5 = vec_ctf(vec_unpackl(data5), 0);
00117 row6 = vec_ctf(vec_unpackh(data6), 0);
00118 alt6 = vec_ctf(vec_unpackl(data6), 0);
00119 row7 = vec_ctf(vec_unpackh(data7), 0);
00120 alt7 = vec_ctf(vec_unpackl(data7), 0);
00121 }
00122
00123
00124
00125
00126
00127 {
00128 const vector float vec_0_298631336 = (vector float)FOUROF(0.298631336f);
00129 const vector float vec_0_390180644 = (vector float)FOUROF(-0.390180644f);
00130 const vector float vec_0_541196100 = (vector float)FOUROF(0.541196100f);
00131 const vector float vec_0_765366865 = (vector float)FOUROF(0.765366865f);
00132 const vector float vec_0_899976223 = (vector float)FOUROF(-0.899976223f);
00133 const vector float vec_1_175875602 = (vector float)FOUROF(1.175875602f);
00134 const vector float vec_1_501321110 = (vector float)FOUROF(1.501321110f);
00135 const vector float vec_1_847759065 = (vector float)FOUROF(-1.847759065f);
00136 const vector float vec_1_961570560 = (vector float)FOUROF(-1.961570560f);
00137 const vector float vec_2_053119869 = (vector float)FOUROF(2.053119869f);
00138 const vector float vec_2_562915447 = (vector float)FOUROF(-2.562915447f);
00139 const vector float vec_3_072711026 = (vector float)FOUROF(3.072711026f);
00140
00141
00142 int whichPass, whichHalf;
00143
00144 for(whichPass = 1; whichPass<=2; whichPass++)
00145 {
00146 for(whichHalf = 1; whichHalf<=2; whichHalf++)
00147 {
00148 vector float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
00149 vector float tmp10, tmp11, tmp12, tmp13;
00150 vector float z1, z2, z3, z4, z5;
00151
00152 tmp0 = vec_add(row0, row7);
00153 tmp7 = vec_sub(row0, row7);
00154 tmp3 = vec_add(row3, row4);
00155 tmp4 = vec_sub(row3, row4);
00156 tmp1 = vec_add(row1, row6);
00157 tmp6 = vec_sub(row1, row6);
00158 tmp2 = vec_add(row2, row5);
00159 tmp5 = vec_sub(row2, row5);
00160
00161 tmp10 = vec_add(tmp0, tmp3);
00162 tmp13 = vec_sub(tmp0, tmp3);
00163 tmp11 = vec_add(tmp1, tmp2);
00164 tmp12 = vec_sub(tmp1, tmp2);
00165
00166
00167
00168 row0 = vec_add(tmp10, tmp11);
00169
00170
00171 row4 = vec_sub(tmp10, tmp11);
00172
00173
00174
00175 z1 = vec_madd(vec_add(tmp12, tmp13), vec_0_541196100, (vector float)zero);
00176
00177
00178
00179 row2 = vec_madd(tmp13, vec_0_765366865, z1);
00180
00181
00182
00183 row6 = vec_madd(tmp12, vec_1_847759065, z1);
00184
00185 z1 = vec_add(tmp4, tmp7);
00186 z2 = vec_add(tmp5, tmp6);
00187 z3 = vec_add(tmp4, tmp6);
00188 z4 = vec_add(tmp5, tmp7);
00189
00190
00191 z5 = vec_madd(vec_add(z3, z4), vec_1_175875602, (vector float)zero);
00192
00193
00194 z3 = vec_madd(z3, vec_1_961570560, z5);
00195
00196
00197 z4 = vec_madd(z4, vec_0_390180644, z5);
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214 row7 = vec_madd(tmp4, vec_0_298631336, vec_madd(z1, vec_0_899976223, z3));
00215
00216
00217
00218 row5 = vec_madd(tmp5, vec_2_053119869, vec_madd(z2, vec_2_562915447, z4));
00219
00220
00221
00222 row3 = vec_madd(tmp6, vec_3_072711026, vec_madd(z2, vec_2_562915447, z3));
00223
00224
00225
00226 row1 = vec_madd(z1, vec_0_899976223, vec_madd(tmp7, vec_1_501321110, z4));
00227
00228
00229
00230
00231
00232 SWAP(row0, alt0);
00233 SWAP(row1, alt1);
00234 SWAP(row2, alt2);
00235 SWAP(row3, alt3);
00236 SWAP(row4, alt4);
00237 SWAP(row5, alt5);
00238 SWAP(row6, alt6);
00239 SWAP(row7, alt7);
00240 }
00241
00242 if (whichPass == 1)
00243 {
00244
00245
00246
00247 SWAP(row4, alt0);
00248 SWAP(row5, alt1);
00249 SWAP(row6, alt2);
00250 SWAP(row7, alt3);
00251
00252
00253 TRANSPOSE4(row0, row1, row2, row3);
00254 TRANSPOSE4(row4, row5, row6, row7);
00255 TRANSPOSE4(alt0, alt1, alt2, alt3);
00256 TRANSPOSE4(alt4, alt5, alt6, alt7);
00257 }
00258 }
00259 }
00260
00261
00262
00263 {
00264 const int* biasAddr;
00265 const vector signed int* qmat;
00266 vector float bias, negBias;
00267
00268 if (s->mb_intra)
00269 {
00270 vector signed int baseVector;
00271
00272
00273
00274 baseVector = vec_cts(vec_splat(row0, 0), 0);
00275 vec_ste(baseVector, 0, &oldBaseValue);
00276
00277 qmat = (vector signed int*)s->q_intra_matrix[qscale];
00278 biasAddr = &(s->intra_quant_bias);
00279 }
00280 else
00281 {
00282 qmat = (vector signed int*)s->q_inter_matrix[qscale];
00283 biasAddr = &(s->inter_quant_bias);
00284 }
00285
00286
00287
00288 {
00289 vector signed int biasInt;
00290 const vector float negOneFloat = (vector float)FOUROF(-1.0f);
00291 LOAD4(biasInt, biasAddr);
00292 bias = vec_ctf(biasInt, QUANT_BIAS_SHIFT);
00293 negBias = vec_madd(bias, negOneFloat, zero);
00294 }
00295
00296 {
00297 vector float q0, q1, q2, q3, q4, q5, q6, q7;
00298
00299 q0 = vec_ctf(qmat[0], QMAT_SHIFT);
00300 q1 = vec_ctf(qmat[2], QMAT_SHIFT);
00301 q2 = vec_ctf(qmat[4], QMAT_SHIFT);
00302 q3 = vec_ctf(qmat[6], QMAT_SHIFT);
00303 q4 = vec_ctf(qmat[8], QMAT_SHIFT);
00304 q5 = vec_ctf(qmat[10], QMAT_SHIFT);
00305 q6 = vec_ctf(qmat[12], QMAT_SHIFT);
00306 q7 = vec_ctf(qmat[14], QMAT_SHIFT);
00307
00308 row0 = vec_sel(vec_madd(row0, q0, negBias), vec_madd(row0, q0, bias),
00309 vec_cmpgt(row0, zero));
00310 row1 = vec_sel(vec_madd(row1, q1, negBias), vec_madd(row1, q1, bias),
00311 vec_cmpgt(row1, zero));
00312 row2 = vec_sel(vec_madd(row2, q2, negBias), vec_madd(row2, q2, bias),
00313 vec_cmpgt(row2, zero));
00314 row3 = vec_sel(vec_madd(row3, q3, negBias), vec_madd(row3, q3, bias),
00315 vec_cmpgt(row3, zero));
00316 row4 = vec_sel(vec_madd(row4, q4, negBias), vec_madd(row4, q4, bias),
00317 vec_cmpgt(row4, zero));
00318 row5 = vec_sel(vec_madd(row5, q5, negBias), vec_madd(row5, q5, bias),
00319 vec_cmpgt(row5, zero));
00320 row6 = vec_sel(vec_madd(row6, q6, negBias), vec_madd(row6, q6, bias),
00321 vec_cmpgt(row6, zero));
00322 row7 = vec_sel(vec_madd(row7, q7, negBias), vec_madd(row7, q7, bias),
00323 vec_cmpgt(row7, zero));
00324
00325 q0 = vec_ctf(qmat[1], QMAT_SHIFT);
00326 q1 = vec_ctf(qmat[3], QMAT_SHIFT);
00327 q2 = vec_ctf(qmat[5], QMAT_SHIFT);
00328 q3 = vec_ctf(qmat[7], QMAT_SHIFT);
00329 q4 = vec_ctf(qmat[9], QMAT_SHIFT);
00330 q5 = vec_ctf(qmat[11], QMAT_SHIFT);
00331 q6 = vec_ctf(qmat[13], QMAT_SHIFT);
00332 q7 = vec_ctf(qmat[15], QMAT_SHIFT);
00333
00334 alt0 = vec_sel(vec_madd(alt0, q0, negBias), vec_madd(alt0, q0, bias),
00335 vec_cmpgt(alt0, zero));
00336 alt1 = vec_sel(vec_madd(alt1, q1, negBias), vec_madd(alt1, q1, bias),
00337 vec_cmpgt(alt1, zero));
00338 alt2 = vec_sel(vec_madd(alt2, q2, negBias), vec_madd(alt2, q2, bias),
00339 vec_cmpgt(alt2, zero));
00340 alt3 = vec_sel(vec_madd(alt3, q3, negBias), vec_madd(alt3, q3, bias),
00341 vec_cmpgt(alt3, zero));
00342 alt4 = vec_sel(vec_madd(alt4, q4, negBias), vec_madd(alt4, q4, bias),
00343 vec_cmpgt(alt4, zero));
00344 alt5 = vec_sel(vec_madd(alt5, q5, negBias), vec_madd(alt5, q5, bias),
00345 vec_cmpgt(alt5, zero));
00346 alt6 = vec_sel(vec_madd(alt6, q6, negBias), vec_madd(alt6, q6, bias),
00347 vec_cmpgt(alt6, zero));
00348 alt7 = vec_sel(vec_madd(alt7, q7, negBias), vec_madd(alt7, q7, bias),
00349 vec_cmpgt(alt7, zero));
00350 }
00351
00352
00353 }
00354
00355
00356 {
00357 vector signed short data0, data1, data2, data3, data4, data5, data6, data7;
00358
00359 data0 = vec_pack(vec_cts(row0, 0), vec_cts(alt0, 0));
00360 data1 = vec_pack(vec_cts(row1, 0), vec_cts(alt1, 0));
00361 data2 = vec_pack(vec_cts(row2, 0), vec_cts(alt2, 0));
00362 data3 = vec_pack(vec_cts(row3, 0), vec_cts(alt3, 0));
00363 data4 = vec_pack(vec_cts(row4, 0), vec_cts(alt4, 0));
00364 data5 = vec_pack(vec_cts(row5, 0), vec_cts(alt5, 0));
00365 data6 = vec_pack(vec_cts(row6, 0), vec_cts(alt6, 0));
00366 data7 = vec_pack(vec_cts(row7, 0), vec_cts(alt7, 0));
00367
00368 {
00369
00370 vector signed int max_q_int, min_q_int;
00371 vector signed short max_q, min_q;
00372
00373 LOAD4(max_q_int, &(s->max_qcoeff));
00374 LOAD4(min_q_int, &(s->min_qcoeff));
00375
00376 max_q = vec_pack(max_q_int, max_q_int);
00377 min_q = vec_pack(min_q_int, min_q_int);
00378
00379 data0 = vec_max(vec_min(data0, max_q), min_q);
00380 data1 = vec_max(vec_min(data1, max_q), min_q);
00381 data2 = vec_max(vec_min(data2, max_q), min_q);
00382 data4 = vec_max(vec_min(data4, max_q), min_q);
00383 data5 = vec_max(vec_min(data5, max_q), min_q);
00384 data6 = vec_max(vec_min(data6, max_q), min_q);
00385 data7 = vec_max(vec_min(data7, max_q), min_q);
00386 }
00387
00388 {
00389 vector bool char zero_01, zero_23, zero_45, zero_67;
00390 vector signed char scanIndices_01, scanIndices_23, scanIndices_45, scanIndices_67;
00391 vector signed char negOne = vec_splat_s8(-1);
00392 vector signed char* scanPtr =
00393 (vector signed char*)(s->intra_scantable.inverse);
00394 signed char lastNonZeroChar;
00395
00396
00397 zero_01 = vec_pack(vec_cmpeq(data0, (vector signed short)zero),
00398 vec_cmpeq(data1, (vector signed short)zero));
00399 zero_23 = vec_pack(vec_cmpeq(data2, (vector signed short)zero),
00400 vec_cmpeq(data3, (vector signed short)zero));
00401 zero_45 = vec_pack(vec_cmpeq(data4, (vector signed short)zero),
00402 vec_cmpeq(data5, (vector signed short)zero));
00403 zero_67 = vec_pack(vec_cmpeq(data6, (vector signed short)zero),
00404 vec_cmpeq(data7, (vector signed short)zero));
00405
00406
00407 scanIndices_01 = vec_sel(scanPtr[0], negOne, zero_01);
00408 scanIndices_23 = vec_sel(scanPtr[1], negOne, zero_23);
00409 scanIndices_45 = vec_sel(scanPtr[2], negOne, zero_45);
00410 scanIndices_67 = vec_sel(scanPtr[3], negOne, zero_67);
00411
00412
00413 scanIndices_01 = vec_max(scanIndices_01, scanIndices_23);
00414 scanIndices_45 = vec_max(scanIndices_45, scanIndices_67);
00415
00416
00417 scanIndices_01 = vec_max(scanIndices_01, scanIndices_45);
00418
00419
00420 scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
00421 vec_mergel(scanIndices_01, negOne));
00422
00423
00424 scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
00425 vec_mergel(scanIndices_01, negOne));
00426
00427
00428 scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
00429 vec_mergel(scanIndices_01, negOne));
00430
00431
00432 scanIndices_01 = vec_max(vec_mergeh(scanIndices_01, negOne),
00433 vec_mergel(scanIndices_01, negOne));
00434
00435 scanIndices_01 = vec_splat(scanIndices_01, 0);
00436
00437
00438 vec_ste(scanIndices_01, 0, &lastNonZeroChar);
00439
00440 lastNonZero = lastNonZeroChar;
00441
00442
00443
00444
00445
00446 if ((lastNonZero > 0) && (s->dsp.idct_permutation_type == FF_TRANSPOSE_IDCT_PERM))
00447 {
00448 TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7);
00449 }
00450
00451 vec_st(data0, 0, data);
00452 vec_st(data1, 16, data);
00453 vec_st(data2, 32, data);
00454 vec_st(data3, 48, data);
00455 vec_st(data4, 64, data);
00456 vec_st(data5, 80, data);
00457 vec_st(data6, 96, data);
00458 vec_st(data7, 112, data);
00459 }
00460 }
00461
00462
00463 if (s->mb_intra)
00464 {
00465 if (!s->h263_aic)
00466 {
00467 if (n < 4)
00468 oldBaseValue /= s->y_dc_scale;
00469 else
00470 oldBaseValue /= s->c_dc_scale;
00471 }
00472
00473
00474 data[0] = (oldBaseValue + 4) >> 3;
00475 }
00476
00477
00478
00479 if ((lastNonZero > 0) &&
00480 (s->dsp.idct_permutation_type != FF_TRANSPOSE_IDCT_PERM) &&
00481 (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM))
00482 {
00483 ff_block_permute(data, s->dsp.idct_permutation,
00484 s->intra_scantable.scantable, lastNonZero);
00485 }
00486
00487 return lastNonZero;
00488 }
00489 #undef FOUROF
00490
00491
00492
00493
00494
00495 void dct_unquantize_h263_altivec(MpegEncContext *s,
00496 DCTELEM *block, int n, int qscale)
00497 {
00498 POWERPC_PERF_DECLARE(altivec_dct_unquantize_h263_num, 1);
00499 int i, level, qmul, qadd;
00500 int nCoeffs;
00501
00502 assert(s->block_last_index[n]>=0);
00503
00504 POWERPC_PERF_START_COUNT(altivec_dct_unquantize_h263_num, 1);
00505
00506 qadd = (qscale - 1) | 1;
00507 qmul = qscale << 1;
00508
00509 if (s->mb_intra) {
00510 if (!s->h263_aic) {
00511 if (n < 4)
00512 block[0] = block[0] * s->y_dc_scale;
00513 else
00514 block[0] = block[0] * s->c_dc_scale;
00515 }else
00516 qadd = 0;
00517 i = 1;
00518 nCoeffs= 63;
00519 } else {
00520 i = 0;
00521 nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
00522 }
00523
00524 {
00525 register const vector signed short vczero = (const vector signed short)vec_splat_s16(0);
00526 DECLARE_ALIGNED_16(short, qmul8[]) =
00527 {
00528 qmul, qmul, qmul, qmul,
00529 qmul, qmul, qmul, qmul
00530 };
00531 DECLARE_ALIGNED_16(short, qadd8[]) =
00532 {
00533 qadd, qadd, qadd, qadd,
00534 qadd, qadd, qadd, qadd
00535 };
00536 DECLARE_ALIGNED_16(short, nqadd8[]) =
00537 {
00538 -qadd, -qadd, -qadd, -qadd,
00539 -qadd, -qadd, -qadd, -qadd
00540 };
00541 register vector signed short blockv, qmulv, qaddv, nqaddv, temp1;
00542 register vector bool short blockv_null, blockv_neg;
00543 register short backup_0 = block[0];
00544 register int j = 0;
00545
00546 qmulv = vec_ld(0, qmul8);
00547 qaddv = vec_ld(0, qadd8);
00548 nqaddv = vec_ld(0, nqadd8);
00549
00550 #if 0 // block *is* 16 bytes-aligned, it seems.
00551
00552 for(j = 0; (j <= nCoeffs) && ((((unsigned long)block) + (j << 1)) & 0x0000000F) ; j++) {
00553 level = block[j];
00554 if (level) {
00555 if (level < 0) {
00556 level = level * qmul - qadd;
00557 } else {
00558 level = level * qmul + qadd;
00559 }
00560 block[j] = level;
00561 }
00562 }
00563 #endif
00564
00565
00566
00567 for(; (j + 7) <= nCoeffs ; j+=8)
00568 {
00569 blockv = vec_ld(j << 1, block);
00570 blockv_neg = vec_cmplt(blockv, vczero);
00571 blockv_null = vec_cmpeq(blockv, vczero);
00572
00573 temp1 = vec_sel(qaddv, nqaddv, blockv_neg);
00574
00575 temp1 = vec_mladd(blockv, qmulv, temp1);
00576
00577 blockv = vec_sel(temp1, blockv, blockv_null);
00578 vec_st(blockv, j << 1, block);
00579 }
00580
00581
00582
00583
00584
00585 for(; j <= nCoeffs ; j++) {
00586 level = block[j];
00587 if (level) {
00588 if (level < 0) {
00589 level = level * qmul - qadd;
00590 } else {
00591 level = level * qmul + qadd;
00592 }
00593 block[j] = level;
00594 }
00595 }
00596
00597 if (i == 1)
00598 {
00599 block[0] = backup_0;
00600 }
00601 }
00602 POWERPC_PERF_STOP_COUNT(altivec_dct_unquantize_h263_num, nCoeffs == 63);
00603 }
00604
00605
00606 extern void idct_put_altivec(uint8_t *dest, int line_size, int16_t *block);
00607 extern void idct_add_altivec(uint8_t *dest, int line_size, int16_t *block);
00608
00609 void MPV_common_init_altivec(MpegEncContext *s)
00610 {
00611 if (s->avctx->lowres==0)
00612 {
00613 if ((s->avctx->idct_algo == FF_IDCT_AUTO) ||
00614 (s->avctx->idct_algo == FF_IDCT_ALTIVEC))
00615 {
00616 s->dsp.idct_put = idct_put_altivec;
00617 s->dsp.idct_add = idct_add_altivec;
00618 s->dsp.idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
00619 }
00620 }
00621
00622
00623 if ((((long)(s->q_intra_matrix) & 0x0f) != 0) ||
00624 (((long)(s->q_inter_matrix) & 0x0f) != 0))
00625 {
00626 av_log(s->avctx, AV_LOG_INFO, "Internal Error: q-matrix blocks must be 16-byte aligned "
00627 "to use AltiVec DCT. Reverting to non-AltiVec version.\n");
00628 return;
00629 }
00630
00631 if (((long)(s->intra_scantable.inverse) & 0x0f) != 0)
00632 {
00633 av_log(s->avctx, AV_LOG_INFO, "Internal Error: scan table blocks must be 16-byte aligned "
00634 "to use AltiVec DCT. Reverting to non-AltiVec version.\n");
00635 return;
00636 }
00637
00638
00639 if ((s->avctx->dct_algo == FF_DCT_AUTO) ||
00640 (s->avctx->dct_algo == FF_DCT_ALTIVEC))
00641 {
00642 #if 0
00643 s->dct_quantize = dct_quantize_altivec;
00644 #endif
00645 s->dct_unquantize_h263_intra = dct_unquantize_h263_altivec;
00646 s->dct_unquantize_h263_inter = dct_unquantize_h263_altivec;
00647 }
00648 }