git.sesse.net Git - vlc/blob - plugins/idct/idct.h

   1 /*****************************************************************************
   2  * idct.h : macros for the inverse discrete cosine transform
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: idct.h,v 1.1 2001/01/13 12:57:20 sam Exp $
   6  *
   7  * Authors: Gaël Hendryckx <jimmy@via.ecp.fr>
   8  *          Christophe Massiot <massiot@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #define SPARSE_SCALE_FACTOR 8
  26 #define DCTSIZE 8 /* 8*8 DCT */
  27
  28 /*****************************************************************************
  29  *  Macros
  30  *****************************************************************************/
  31
  32 /* We assume that right shift corresponds to signed division by 2 with
  33  * rounding towards minus infinity.  This is correct for typical "arithmetic
  34  * shift" instructions that shift in copies of the sign bit.  But some
  35  * C compilers implement >> with an unsigned shift.  For these machines you
  36  * must define RIGHT_SHIFT_IS_UNSIGNED.
  37  * RIGHT_SHIFT provides a proper signed right shift of an s32 quantity.
  38  * It is only applied with constant shift counts.  SHIFT_TEMPS must be
  39  * included in the variables of any routine using RIGHT_SHIFT.
  40  */
  41
  42 #ifdef RIGHT_SHIFT_IS_UNSIGNED
  43 #define SHIFT_TEMPS s32 shift_temp;
  44 #define RIGHT_SHIFT(x,shft)  \
  45     ((shift_temp = (x)) < 0 ? \
  46      (shift_temp >> (shft)) | ((~((s32) 0)) << (32-(shft))) : \
  47      (shift_temp >> (shft)))
  48 #else
  49 #define SHIFT_TEMPS
  50 #define RIGHT_SHIFT(x,shft) ((x) >> (shft))
  51 #endif
  52
  53 /*
  54  * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT
  55  * on each column.  Direct algorithms are also available, but they are
  56  * much more complex and seem not to be any faster when reduced to code.
  57  *
  58  * The poop on this scaling stuff is as follows:
  59  *
  60  * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
  61  * larger than the true IDCT outputs.  The final outputs are therefore
  62  * a factor of N larger than desired; since N=8 this can be cured by
  63  * a simple right shift at the end of the algorithm.  The advantage of
  64  * this arrangement is that we save two multiplications per 1-D IDCT,
  65  * because the y0 and y4 inputs need not be divided by sqrt(N).
  66  *
  67  * We have to do addition and subtraction of the integer inputs, which
  68  * is no problem, and multiplication by fractional constants, which is
  69  * a problem to do in integer arithmetic.  We multiply all the constants
  70  * by CONST_SCALE and convert them to integer constants (thus retaining
  71  * CONST_BITS bits of precision in the constants).  After doing a
  72  * multiplication we have to divide the product by CONST_SCALE, with proper
  73  * rounding, to produce the correct output.  This division can be done
  74  * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
  75  * as long as possible so that partial sums can be added together with
  76  * full fractional precision.
  77  *
  78  * The outputs of the first pass are scaled up by PASS1_BITS bits so that
  79  * they are represented to better-than-integral precision.  These outputs
  80  * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
  81  * with the recommended scaling.  (To scale up 12-bit sample data further, an
  82  * intermediate s32 array would be needed.)
  83  *
  84  * To avoid overflow of the 32-bit intermediate results in pass 2, we must
  85  * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
  86  * shows that the values given below are the most effective.
  87  */
  88
  89 #define CONST_BITS 8                         /* Jimmy chose this constant :) */
  90
  91 #ifdef EIGHT_BIT_SAMPLES
  92 #define PASS1_BITS  2
  93 #else
  94 #define PASS1_BITS  1           /* lose a little precision to avoid overflow */
  95 #endif
  96
  97 #define ONE     ((s32) 1)
  98
  99 #define CONST_SCALE (ONE << CONST_BITS)
 100
 101 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
 102  * IMPORTANT: if your compiler doesn't do this arithmetic at compile time,
 103  * you will pay a significant penalty in run time.  In that case, figure
 104  * the correct integer constant values and insert them by hand.
 105  */
 106
 107 #define FIX(x)  ((s32) ((x) * CONST_SCALE + 0.5))
 108
 109 /* When adding two opposite-signed fixes, the 0.5 cancels */
 110 #define FIX2(x) ((s32) ((x) * CONST_SCALE))
 111
 112 /* Descale and correctly round an s32 value that's scaled by N bits.
 113  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
 114  * the fudge factor is correct for either sign of X.
 115  */
 116
 117 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
 118
 119 /* Multiply an s32 variable by an s32 constant to yield an s32 result.
 120  * For 8-bit samples with the recommended scaling, all the variable
 121  * and constant values involved are no more than 16 bits wide, so a
 122  * 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
 123  * this provides a useful speedup on many machines.
 124  * There is no way to specify a 16x16->32 multiply in portable C, but
 125  * some C compilers will do the right thing if you provide the correct
 126  * combination of casts.
 127  * NB: for 12-bit samples, a full 32-bit multiplication will be needed.
 128  */
 129
 130 #ifdef EIGHT_BIT_SAMPLES
 131 #ifdef SHORTxSHORT_32                        /* may work if 'int' is 32 bits */
 132 #define MULTIPLY(var,const)  (((INT16) (var)) * ((INT16) (const)))
 133 #endif
 134 #ifdef SHORTxLCONST_32                 /* known to work with Microsoft C 6.0 */
 135 #define MULTIPLY(var,const)  (((INT16) (var)) * ((s32) (const)))
 136 #endif
 137 #endif
 138
 139 #ifndef MULTIPLY                                       /* default definition */
 140 #define MULTIPLY(var,const)  ((var) * (const))
 141 #endif
 142