MythTV: idct_alpha.c Source File

00001 /*
00002  * idct_alpha.c
00003  * Copyright (C) 2002-2003 Falk Hueffner <falk@debian.org>
00004  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
00005  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
00006  *
00007  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
00008  * See http://libmpeg2.sourceforge.net/ for updates.
00009  *
00010  * mpeg2dec is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * mpeg2dec is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU General Public License
00021  * along with this program; if not, write to the Free Software
00022  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00023  */
00024 
00025 #include "mpeg2config.h"
00026 
00027 #if ARCH_ALPHA
00028 
00029 #include <stdlib.h>
00030 #include <inttypes.h>
00031 
00032 #include "mpeg2.h"
00033 #include "attributes.h"
00034 #include "mpeg2_internal.h"
00035 #include "alpha_asm.h"
00036 
00037 #define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */
00038 #define W2 2676 /* 2048 * sqrt (2) * cos (2 * pi / 16) */
00039 #define W3 2408 /* 2048 * sqrt (2) * cos (3 * pi / 16) */
00040 #define W5 1609 /* 2048 * sqrt (2) * cos (5 * pi / 16) */
00041 #define W6 1108 /* 2048 * sqrt (2) * cos (6 * pi / 16) */
00042 #define W7 565  /* 2048 * sqrt (2) * cos (7 * pi / 16) */
00043 
00044 extern uint8_t mpeg2_clip[3840 * 2 + 256];
00045 #define CLIP(i) ((mpeg2_clip + 3840)[i])
00046 
00047 #if 0
00048 #define BUTTERFLY(t0,t1,W0,W1,d0,d1)    \
00049 do {                                    \
00050     t0 = W0 * d0 + W1 * d1;                     \
00051     t1 = W0 * d1 - W1 * d0;                     \
00052 } while (0)
00053 #else
00054 #define BUTTERFLY(t0,t1,W0,W1,d0,d1)    \
00055 do {                                    \
00056     int_fast32_t tmp = W0 * (d0 + d1);  \
00057     t0 = tmp + (W1 - W0) * d1;          \
00058     t1 = tmp - (W1 + W0) * d0;          \
00059 } while (0)
00060 #endif
00061 
00062 static inline void idct_row (int16_t * const block)
00063 {
00064     uint64_t l, r;
00065     int_fast32_t d0, d1, d2, d3;
00066     int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
00067     int_fast32_t t0, t1, t2, t3;
00068 
00069     l = ldq (block);
00070     r = ldq (block + 4);
00071 
00072     /* shortcut */
00073     if (likely (!((l & ~0xffffUL) | r))) {
00074         uint64_t tmp = (uint16_t) (l >> 1);
00075         tmp |= tmp << 16;
00076         tmp |= tmp << 32;
00077         ((int32_t *)block)[0] = tmp;
00078         ((int32_t *)block)[1] = tmp;
00079         ((int32_t *)block)[2] = tmp;
00080         ((int32_t *)block)[3] = tmp;
00081         return;
00082     }
00083 
00084     d0 = (sextw (l) << 11) + 2048;
00085     d1 = sextw (extwl (l, 2));
00086     d2 = sextw (extwl (l, 4)) << 11;
00087     d3 = sextw (extwl (l, 6));
00088     t0 = d0 + d2;
00089     t1 = d0 - d2;
00090     BUTTERFLY (t2, t3, W6, W2, d3, d1);
00091     a0 = t0 + t2;
00092     a1 = t1 + t3;
00093     a2 = t1 - t3;
00094     a3 = t0 - t2;
00095 
00096     d0 = sextw (r);
00097     d1 = sextw (extwl (r, 2));
00098     d2 = sextw (extwl (r, 4));
00099     d3 = sextw (extwl (r, 6));
00100     BUTTERFLY (t0, t1, W7, W1, d3, d0);
00101     BUTTERFLY (t2, t3, W3, W5, d1, d2);
00102     b0 = t0 + t2;
00103     b3 = t1 + t3;
00104     t0 -= t2;
00105     t1 -= t3;
00106     b1 = ((t0 + t1) >> 8) * 181;
00107     b2 = ((t0 - t1) >> 8) * 181;
00108 
00109     block[0] = (a0 + b0) >> 12;
00110     block[1] = (a1 + b1) >> 12;
00111     block[2] = (a2 + b2) >> 12;
00112     block[3] = (a3 + b3) >> 12;
00113     block[4] = (a3 - b3) >> 12;
00114     block[5] = (a2 - b2) >> 12;
00115     block[6] = (a1 - b1) >> 12;
00116     block[7] = (a0 - b0) >> 12;
00117 }
00118 
00119 static inline void idct_col (int16_t * const block)
00120 {
00121     int_fast32_t d0, d1, d2, d3;
00122     int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
00123     int_fast32_t t0, t1, t2, t3;
00124 
00125     d0 = (block[8*0] << 11) + 65536;
00126     d1 = block[8*1];
00127     d2 = block[8*2] << 11;
00128     d3 = block[8*3];
00129     t0 = d0 + d2;
00130     t1 = d0 - d2;
00131     BUTTERFLY (t2, t3, W6, W2, d3, d1);
00132     a0 = t0 + t2;
00133     a1 = t1 + t3;
00134     a2 = t1 - t3;
00135     a3 = t0 - t2;
00136 
00137     d0 = block[8*4];
00138     d1 = block[8*5];
00139     d2 = block[8*6];
00140     d3 = block[8*7];
00141     BUTTERFLY (t0, t1, W7, W1, d3, d0);
00142     BUTTERFLY (t2, t3, W3, W5, d1, d2);
00143     b0 = t0 + t2;
00144     b3 = t1 + t3;
00145     t0 -= t2;
00146     t1 -= t3;
00147     b1 = ((t0 + t1) >> 8) * 181;
00148     b2 = ((t0 - t1) >> 8) * 181;
00149 
00150     block[8*0] = (a0 + b0) >> 17;
00151     block[8*1] = (a1 + b1) >> 17;
00152     block[8*2] = (a2 + b2) >> 17;
00153     block[8*3] = (a3 + b3) >> 17;
00154     block[8*4] = (a3 - b3) >> 17;
00155     block[8*5] = (a2 - b2) >> 17;
00156     block[8*6] = (a1 - b1) >> 17;
00157     block[8*7] = (a0 - b0) >> 17;
00158 }
00159 
00160 void mpeg2_idct_copy_mvi (int16_t * block, uint8_t * dest, const int stride)
00161 {
00162     uint64_t clampmask;
00163     int i;
00164 
00165     for (i = 0; i < 8; i++)
00166         idct_row (block + 8 * i);
00167 
00168     for (i = 0; i < 8; i++)
00169         idct_col (block + i);
00170 
00171     clampmask = zap (-1, 0xaa); /* 0x00ff00ff00ff00ff */
00172     do {
00173         uint64_t shorts0, shorts1;
00174 
00175         shorts0 = ldq (block);
00176         shorts0 = maxsw4 (shorts0, 0);
00177         shorts0 = minsw4 (shorts0, clampmask);
00178         stl (pkwb (shorts0), dest);
00179 
00180         shorts1 = ldq (block + 4);
00181         shorts1 = maxsw4 (shorts1, 0);
00182         shorts1 = minsw4 (shorts1, clampmask);
00183         stl (pkwb (shorts1), dest + 4);
00184 
00185         stq (0, block);
00186         stq (0, block + 4);
00187 
00188         dest += stride;
00189         block += 8;
00190     } while (--i);
00191 }
00192 
00193 void mpeg2_idct_add_mvi (const int last, int16_t * block,
00194                          uint8_t * dest, const int stride)
00195 {
00196     uint64_t clampmask;
00197     uint64_t signmask;
00198     int i;
00199 
00200     if (last != 129 || (block[0] & (7 << 4)) == (4 << 4)) {
00201         for (i = 0; i < 8; i++)
00202             idct_row (block + 8 * i);
00203         for (i = 0; i < 8; i++)
00204             idct_col (block + i);
00205         clampmask = zap (-1, 0xaa);     /* 0x00ff00ff00ff00ff */
00206         signmask = zap (-1, 0x33);
00207         signmask ^= signmask >> 1;      /* 0x8000800080008000 */
00208 
00209         do {
00210             uint64_t shorts0, pix0, signs0;
00211             uint64_t shorts1, pix1, signs1;
00212 
00213             shorts0 = ldq (block);
00214             shorts1 = ldq (block + 4);
00215 
00216             pix0 = unpkbw (ldl (dest));
00217             /* signed subword add (MMX paddw).  */
00218             signs0 = shorts0 & signmask;
00219             shorts0 &= ~signmask;
00220             shorts0 += pix0;
00221             shorts0 ^= signs0;
00222             /* clamp. */
00223             shorts0 = maxsw4 (shorts0, 0);
00224             shorts0 = minsw4 (shorts0, clampmask);      
00225 
00226             /* next 4.  */
00227             pix1 = unpkbw (ldl (dest + 4));
00228             signs1 = shorts1 & signmask;
00229             shorts1 &= ~signmask;
00230             shorts1 += pix1;
00231             shorts1 ^= signs1;
00232             shorts1 = maxsw4 (shorts1, 0);
00233             shorts1 = minsw4 (shorts1, clampmask);
00234 
00235             stl (pkwb (shorts0), dest);
00236             stl (pkwb (shorts1), dest + 4);
00237             stq (0, block);
00238             stq (0, block + 4);
00239 
00240             dest += stride;
00241             block += 8;
00242         } while (--i);
00243     } else {
00244         int DC;
00245         uint64_t p0, p1, p2, p3, p4, p5, p6, p7;
00246         uint64_t DCs;
00247 
00248         DC = (block[0] + 64) >> 7;
00249         block[0] = block[63] = 0;
00250 
00251         p0 = ldq (dest + 0 * stride);
00252         p1 = ldq (dest + 1 * stride);
00253         p2 = ldq (dest + 2 * stride);
00254         p3 = ldq (dest + 3 * stride);
00255         p4 = ldq (dest + 4 * stride);
00256         p5 = ldq (dest + 5 * stride);
00257         p6 = ldq (dest + 6 * stride);
00258         p7 = ldq (dest + 7 * stride);
00259 
00260         if (DC > 0) {
00261             DCs = BYTE_VEC (likely (DC <= 255) ? DC : 255);
00262             p0 += minub8 (DCs, ~p0);
00263             p1 += minub8 (DCs, ~p1);
00264             p2 += minub8 (DCs, ~p2);
00265             p3 += minub8 (DCs, ~p3);
00266             p4 += minub8 (DCs, ~p4);
00267             p5 += minub8 (DCs, ~p5);
00268             p6 += minub8 (DCs, ~p6);
00269             p7 += minub8 (DCs, ~p7);
00270         } else {
00271             DCs = BYTE_VEC (likely (-DC <= 255) ? -DC : 255);
00272             p0 -= minub8 (DCs, p0);
00273             p1 -= minub8 (DCs, p1);
00274             p2 -= minub8 (DCs, p2);
00275             p3 -= minub8 (DCs, p3);
00276             p4 -= minub8 (DCs, p4);
00277             p5 -= minub8 (DCs, p5);
00278             p6 -= minub8 (DCs, p6);
00279             p7 -= minub8 (DCs, p7);
00280         }
00281 
00282         stq (p0, dest + 0 * stride);
00283         stq (p1, dest + 1 * stride);
00284         stq (p2, dest + 2 * stride);
00285         stq (p3, dest + 3 * stride);
00286         stq (p4, dest + 4 * stride);
00287         stq (p5, dest + 5 * stride);
00288         stq (p6, dest + 6 * stride);
00289         stq (p7, dest + 7 * stride);
00290     }
00291 }
00292 
00293 void mpeg2_idct_copy_alpha (int16_t * block, uint8_t * dest, const int stride)
00294 {
00295     int i;
00296 
00297     for (i = 0; i < 8; i++)
00298         idct_row (block + 8 * i);
00299     for (i = 0; i < 8; i++)
00300         idct_col (block + i);
00301     do {
00302         dest[0] = CLIP (block[0]);
00303         dest[1] = CLIP (block[1]);
00304         dest[2] = CLIP (block[2]);
00305         dest[3] = CLIP (block[3]);
00306         dest[4] = CLIP (block[4]);
00307         dest[5] = CLIP (block[5]);
00308         dest[6] = CLIP (block[6]);
00309         dest[7] = CLIP (block[7]);
00310 
00311         stq(0, block);
00312         stq(0, block + 4);
00313 
00314         dest += stride;
00315         block += 8;
00316     } while (--i);
00317 }
00318 
00319 void mpeg2_idct_add_alpha (const int last, int16_t * block,
00320                            uint8_t * dest, const int stride)
00321 {
00322     int i;
00323 
00324     if (last != 129 || (block[0] & (7 << 4)) == (4 << 4)) {
00325         for (i = 0; i < 8; i++)
00326             idct_row (block + 8 * i);
00327         for (i = 0; i < 8; i++)
00328             idct_col (block + i);
00329         do {
00330             dest[0] = CLIP (block[0] + dest[0]);
00331             dest[1] = CLIP (block[1] + dest[1]);
00332             dest[2] = CLIP (block[2] + dest[2]);
00333             dest[3] = CLIP (block[3] + dest[3]);
00334             dest[4] = CLIP (block[4] + dest[4]);
00335             dest[5] = CLIP (block[5] + dest[5]);
00336             dest[6] = CLIP (block[6] + dest[6]);
00337             dest[7] = CLIP (block[7] + dest[7]);
00338 
00339             stq(0, block);
00340             stq(0, block + 4);
00341 
00342             dest += stride;
00343             block += 8;
00344         } while (--i);
00345     } else {
00346         int DC;
00347 
00348         DC = (block[0] + 64) >> 7;
00349         block[0] = block[63] = 0;
00350         i = 8;
00351         do {
00352             dest[0] = CLIP (DC + dest[0]);
00353             dest[1] = CLIP (DC + dest[1]);
00354             dest[2] = CLIP (DC + dest[2]);
00355             dest[3] = CLIP (DC + dest[3]);
00356             dest[4] = CLIP (DC + dest[4]);
00357             dest[5] = CLIP (DC + dest[5]);
00358             dest[6] = CLIP (DC + dest[6]);
00359             dest[7] = CLIP (DC + dest[7]);
00360             dest += stride;
00361         } while (--i);
00362     }
00363 }
00364 
00365 void mpeg2_idct_alpha_init (void)
00366 {
00367     extern uint8_t mpeg2_scan_norm[64];
00368     extern uint8_t mpeg2_scan_alt[64];
00369     int i, j;
00370 
00371     for (i = 0; i < 64; i++) {
00372         j = mpeg2_scan_norm[i];
00373         mpeg2_scan_norm[i] = ((j & 0x36) >> 1) | ((j & 0x09) << 2);
00374         j = mpeg2_scan_alt[i];
00375         mpeg2_scan_alt[i] = ((j & 0x36) >> 1) | ((j & 0x09) << 2);
00376     }
00377 }
00378 
00379 #endif /* ARCH_ALPHA */