Home | History | Annotate | Download | only in libjpeg
      1 /*
      2  * jdct.h
      3  *
      4  * Copyright (C) 1994-1996, Thomas G. Lane.
      5  * This file is part of the Independent JPEG Group's software.
      6  * For conditions of distribution and use, see the accompanying README file.
      7  *
      8  * This include file contains common declarations for the forward and
      9  * inverse DCT modules.  These declarations are private to the DCT managers
     10  * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
     11  * The individual DCT algorithms are kept in separate files to ease
     12  * machine-dependent tuning (e.g., assembly coding).
     13  */
     14 
     15 
     16 /*
     17  * A forward DCT routine is given a pointer to an input sample array and
     18  * a pointer to a work area of type DCTELEM[]; the DCT is to be performed
     19  * in-place in that buffer.  Type DCTELEM is int for 8-bit samples, INT32
     20  * for 12-bit samples.  (NOTE: Floating-point DCT implementations use an
     21  * array of type FAST_FLOAT, instead.)
     22  * The input data is to be fetched from the sample array starting at a
     23  * specified column.  (Any row offset needed will be applied to the array
     24  * pointer before it is passed to the FDCT code.)
     25  * Note that the number of samples fetched by the FDCT routine is
     26  * DCT_h_scaled_size * DCT_v_scaled_size.
     27  * The DCT outputs are returned scaled up by a factor of 8; they therefore
     28  * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
     29  * convention improves accuracy in integer implementations and saves some
     30  * work in floating-point ones.
     31  * Quantization of the output coefficients is done by jcdctmgr.c.
     32  */
     33 
     34 #if BITS_IN_JSAMPLE == 8
     35 typedef int DCTELEM;		/* 16 or 32 bits is fine */
     36 #else
     37 typedef INT32 DCTELEM;		/* must have 32 bits */
     38 #endif
     39 
     40 typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data,
     41                                                JSAMPARRAY sample_data,
     42                                                JDIMENSION start_col));
     43 typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data,
     44                                              JSAMPARRAY sample_data,
     45                                              JDIMENSION start_col));
     46 
     47 
     48 /*
     49  * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
     50  * to an output sample array.  The routine must dequantize the input data as
     51  * well as perform the IDCT; for dequantization, it uses the multiplier table
     52  * pointed to by compptr->dct_table.  The output data is to be placed into the
     53  * sample array starting at a specified column.  (Any row offset needed will
     54  * be applied to the array pointer before it is passed to the IDCT code.)
     55  * Note that the number of samples emitted by the IDCT routine is
     56  * DCT_h_scaled_size * DCT_v_scaled_size.
     57  */
     58 
     59 /* typedef inverse_DCT_method_ptr is declared in jpegint.h */
     60 
     61 /*
     62  * Each IDCT routine has its own ideas about the best dct_table element type.
     63  */
     64 
     65 typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
     66 #if BITS_IN_JSAMPLE == 8
     67 typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
     68 #define IFAST_SCALE_BITS  2	/* fractional bits in scale factors */
     69 #else
     70 typedef INT32 IFAST_MULT_TYPE;	/* need 32 bits for scaled quantizers */
     71 #define IFAST_SCALE_BITS  13	/* fractional bits in scale factors */
     72 #endif
     73 typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
     74 
     75 
     76 /*
     77  * Each IDCT routine is responsible for range-limiting its results and
     78  * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
     79  * be quite far out of range if the input data is corrupt, so a bulletproof
     80  * range-limiting step is required.  We use a mask-and-table-lookup method
     81  * to do the combined operations quickly.  See the comments with
     82  * prepare_range_limit_table (in jdmaster.c) for more info.
     83  */
     84 
     85 #define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit + CENTERJSAMPLE)
     86 
     87 #define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
     88 
     89 
     90 /* Short forms of external names for systems with brain-damaged linkers. */
     91 
     92 #ifdef NEED_SHORT_EXTERNAL_NAMES
     93 #define jpeg_fdct_islow		jFDislow
     94 #define jpeg_fdct_ifast		jFDifast
     95 #define jpeg_fdct_float		jFDfloat
     96 #define jpeg_fdct_7x7		jFD7x7
     97 #define jpeg_fdct_6x6		jFD6x6
     98 #define jpeg_fdct_5x5		jFD5x5
     99 #define jpeg_fdct_4x4		jFD4x4
    100 #define jpeg_fdct_3x3		jFD3x3
    101 #define jpeg_fdct_2x2		jFD2x2
    102 #define jpeg_fdct_1x1		jFD1x1
    103 #define jpeg_fdct_9x9		jFD9x9
    104 #define jpeg_fdct_10x10		jFD10x10
    105 #define jpeg_fdct_11x11		jFD11x11
    106 #define jpeg_fdct_12x12		jFD12x12
    107 #define jpeg_fdct_13x13		jFD13x13
    108 #define jpeg_fdct_14x14		jFD14x14
    109 #define jpeg_fdct_15x15		jFD15x15
    110 #define jpeg_fdct_16x16		jFD16x16
    111 #define jpeg_fdct_16x8		jFD16x8
    112 #define jpeg_fdct_14x7		jFD14x7
    113 #define jpeg_fdct_12x6		jFD12x6
    114 #define jpeg_fdct_10x5		jFD10x5
    115 #define jpeg_fdct_8x4		jFD8x4
    116 #define jpeg_fdct_6x3		jFD6x3
    117 #define jpeg_fdct_4x2		jFD4x2
    118 #define jpeg_fdct_2x1		jFD2x1
    119 #define jpeg_fdct_8x16		jFD8x16
    120 #define jpeg_fdct_7x14		jFD7x14
    121 #define jpeg_fdct_6x12		jFD6x12
    122 #define jpeg_fdct_5x10		jFD5x10
    123 #define jpeg_fdct_4x8		jFD4x8
    124 #define jpeg_fdct_3x6		jFD3x6
    125 #define jpeg_fdct_2x4		jFD2x4
    126 #define jpeg_fdct_1x2		jFD1x2
    127 #define jpeg_idct_islow		jRDislow
    128 #define jpeg_idct_ifast		jRDifast
    129 #define jpeg_idct_float		jRDfloat
    130 #define jpeg_idct_7x7		jRD7x7
    131 #define jpeg_idct_6x6		jRD6x6
    132 #define jpeg_idct_5x5		jRD5x5
    133 #define jpeg_idct_4x4		jRD4x4
    134 #define jpeg_idct_3x3		jRD3x3
    135 #define jpeg_idct_2x2		jRD2x2
    136 #define jpeg_idct_1x1		jRD1x1
    137 #define jpeg_idct_9x9		jRD9x9
    138 #define jpeg_idct_10x10		jRD10x10
    139 #define jpeg_idct_11x11		jRD11x11
    140 #define jpeg_idct_12x12		jRD12x12
    141 #define jpeg_idct_13x13		jRD13x13
    142 #define jpeg_idct_14x14		jRD14x14
    143 #define jpeg_idct_15x15		jRD15x15
    144 #define jpeg_idct_16x16		jRD16x16
    145 #define jpeg_idct_16x8		jRD16x8
    146 #define jpeg_idct_14x7		jRD14x7
    147 #define jpeg_idct_12x6		jRD12x6
    148 #define jpeg_idct_10x5		jRD10x5
    149 #define jpeg_idct_8x4		jRD8x4
    150 #define jpeg_idct_6x3		jRD6x3
    151 #define jpeg_idct_4x2		jRD4x2
    152 #define jpeg_idct_2x1		jRD2x1
    153 #define jpeg_idct_8x16		jRD8x16
    154 #define jpeg_idct_7x14		jRD7x14
    155 #define jpeg_idct_6x12		jRD6x12
    156 #define jpeg_idct_5x10		jRD5x10
    157 #define jpeg_idct_4x8		jRD4x8
    158 #define jpeg_idct_3x6		jRD3x8
    159 #define jpeg_idct_2x4		jRD2x4
    160 #define jpeg_idct_1x2		jRD1x2
    161 #endif /* NEED_SHORT_EXTERNAL_NAMES */
    162 
    163 /* Extern declarations for the forward and inverse DCT routines. */
    164 
    165 EXTERN(void) jpeg_fdct_islow
    166     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    167 EXTERN(void) jpeg_fdct_ifast
    168     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    169 EXTERN(void) jpeg_fdct_float
    170     JPP((FAST_FLOAT * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    171 EXTERN(void) jpeg_fdct_7x7
    172     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    173 EXTERN(void) jpeg_fdct_6x6
    174     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    175 EXTERN(void) jpeg_fdct_5x5
    176     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    177 EXTERN(void) jpeg_fdct_4x4
    178     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    179 EXTERN(void) jpeg_fdct_3x3
    180     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    181 EXTERN(void) jpeg_fdct_2x2
    182     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    183 EXTERN(void) jpeg_fdct_1x1
    184     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    185 EXTERN(void) jpeg_fdct_9x9
    186     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    187 EXTERN(void) jpeg_fdct_10x10
    188     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    189 EXTERN(void) jpeg_fdct_11x11
    190     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    191 EXTERN(void) jpeg_fdct_12x12
    192     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    193 EXTERN(void) jpeg_fdct_13x13
    194     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    195 EXTERN(void) jpeg_fdct_14x14
    196     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    197 EXTERN(void) jpeg_fdct_15x15
    198     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    199 EXTERN(void) jpeg_fdct_16x16
    200     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    201 EXTERN(void) jpeg_fdct_16x8
    202     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    203 EXTERN(void) jpeg_fdct_14x7
    204     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    205 EXTERN(void) jpeg_fdct_12x6
    206     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    207 EXTERN(void) jpeg_fdct_10x5
    208     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    209 EXTERN(void) jpeg_fdct_8x4
    210     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    211 EXTERN(void) jpeg_fdct_6x3
    212     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    213 EXTERN(void) jpeg_fdct_4x2
    214     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    215 EXTERN(void) jpeg_fdct_2x1
    216     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    217 EXTERN(void) jpeg_fdct_8x16
    218     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    219 EXTERN(void) jpeg_fdct_7x14
    220     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    221 EXTERN(void) jpeg_fdct_6x12
    222     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    223 EXTERN(void) jpeg_fdct_5x10
    224     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    225 EXTERN(void) jpeg_fdct_4x8
    226     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    227 EXTERN(void) jpeg_fdct_3x6
    228     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    229 EXTERN(void) jpeg_fdct_2x4
    230     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    231 EXTERN(void) jpeg_fdct_1x2
    232     JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
    233 
    234 EXTERN(void) jpeg_idct_islow
    235     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    236          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    237 EXTERN(void) jpeg_idct_ifast
    238     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    239          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    240 EXTERN(void) jpeg_idct_float
    241     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    242          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    243 EXTERN(void) jpeg_idct_7x7
    244     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    245          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    246 EXTERN(void) jpeg_idct_6x6
    247     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    248          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    249 EXTERN(void) jpeg_idct_5x5
    250     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    251          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    252 EXTERN(void) jpeg_idct_4x4
    253     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    254          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    255 EXTERN(void) jpeg_idct_3x3
    256     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    257          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    258 EXTERN(void) jpeg_idct_2x2
    259     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    260          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    261 EXTERN(void) jpeg_idct_1x1
    262     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    263          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    264 EXTERN(void) jpeg_idct_9x9
    265     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    266          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    267 EXTERN(void) jpeg_idct_10x10
    268     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    269          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    270 EXTERN(void) jpeg_idct_11x11
    271     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    272          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    273 EXTERN(void) jpeg_idct_12x12
    274     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    275          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    276 EXTERN(void) jpeg_idct_13x13
    277     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    278          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    279 EXTERN(void) jpeg_idct_14x14
    280     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    281          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    282 EXTERN(void) jpeg_idct_15x15
    283     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    284          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    285 EXTERN(void) jpeg_idct_16x16
    286     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    287          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    288 EXTERN(void) jpeg_idct_16x8
    289     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    290          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    291 EXTERN(void) jpeg_idct_14x7
    292     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    293          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    294 EXTERN(void) jpeg_idct_12x6
    295     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    296          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    297 EXTERN(void) jpeg_idct_10x5
    298     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    299          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    300 EXTERN(void) jpeg_idct_8x4
    301     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    302          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    303 EXTERN(void) jpeg_idct_6x3
    304     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    305          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    306 EXTERN(void) jpeg_idct_4x2
    307     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    308          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    309 EXTERN(void) jpeg_idct_2x1
    310     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    311          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    312 EXTERN(void) jpeg_idct_8x16
    313     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    314          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    315 EXTERN(void) jpeg_idct_7x14
    316     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    317          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    318 EXTERN(void) jpeg_idct_6x12
    319     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    320          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    321 EXTERN(void) jpeg_idct_5x10
    322     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    323          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    324 EXTERN(void) jpeg_idct_4x8
    325     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    326          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    327 EXTERN(void) jpeg_idct_3x6
    328     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    329          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    330 EXTERN(void) jpeg_idct_2x4
    331     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    332          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    333 EXTERN(void) jpeg_idct_1x2
    334     JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
    335          JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
    336 
    337 
    338 /*
    339  * Macros for handling fixed-point arithmetic; these are used by many
    340  * but not all of the DCT/IDCT modules.
    341  *
    342  * All values are expected to be of type INT32.
    343  * Fractional constants are scaled left by CONST_BITS bits.
    344  * CONST_BITS is defined within each module using these macros,
    345  * and may differ from one module to the next.
    346  */
    347 
    348 #define ONE	((INT32) 1)
    349 #define CONST_SCALE (ONE << CONST_BITS)
    350 
    351 /* Convert a positive real constant to an integer scaled by CONST_SCALE.
    352  * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
    353  * thus causing a lot of useless floating-point operations at run time.
    354  */
    355 
    356 #define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5))
    357 
    358 /* Descale and correctly round an INT32 value that's scaled by N bits.
    359  * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
    360  * the fudge factor is correct for either sign of X.
    361  */
    362 
    363 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
    364 
    365 /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
    366  * This macro is used only when the two inputs will actually be no more than
    367  * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
    368  * full 32x32 multiply.  This provides a useful speedup on many machines.
    369  * Unfortunately there is no way to specify a 16x16->32 multiply portably
    370  * in C, but some C compilers will do the right thing if you provide the
    371  * correct combination of casts.
    372  */
    373 
    374 #ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
    375 #define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
    376 #endif
    377 #ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
    378 #define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT32) (const)))
    379 #endif
    380 
    381 #ifndef MULTIPLY16C16		/* default definition */
    382 #define MULTIPLY16C16(var,const)  ((var) * (const))
    383 #endif
    384 
    385 /* Same except both inputs are variables. */
    386 
    387 #ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
    388 #define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
    389 #endif
    390 
    391 #ifndef MULTIPLY16V16		/* default definition */
    392 #define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
    393 #endif
    394