Skip to content
Snippets Groups Projects
Select Git revision
  • 62ca8c2f30c50354a02d857864fde317afcff26d
  • master default
  • cgnsUnstructured
  • partitioning
  • poppler
  • HighOrderBLCurving
  • gmsh_3_0_4
  • gmsh_3_0_3
  • gmsh_3_0_2
  • gmsh_3_0_1
  • gmsh_3_0_0
  • gmsh_2_16_0
  • gmsh_2_15_0
  • gmsh_2_14_1
  • gmsh_2_14_0
  • gmsh_2_13_2
  • gmsh_2_13_1
  • gmsh_2_12_0
  • gmsh_2_11_0
  • gmsh_2_10_1
  • gmsh_2_10_0
  • gmsh_2_9_3
  • gmsh_2_9_2
  • gmsh_2_9_1
  • gmsh_2_9_0
  • gmsh_2_8_6
26 results

Options.cpp

Blame
  • Forked from gmsh / gmsh
    Source project has a limited visibility.
    jrevdct.cpp 35.90 KiB
    /*
     * jrevdct.c
     *
     * Copyright (C) 1991, 1992, Thomas G. Lane.
     * This file is part of the Independent JPEG Group's software.
     * For conditions of distribution and use, see the accompanying README file.
     *
     * This file contains the basic inverse-DCT transformation subroutine.
     *
     * This implementation is based on an algorithm described in
     *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
     *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
     *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
     * The primary algorithm described there uses 11 multiplies and 29 adds.
     * We use their alternate method with 12 multiplies and 32 adds.
     * The advantage of this method is that no data path contains more than one
     * multiplication; this allows a very simple and accurate implementation in
     * scaled fixed-point arithmetic, with a minimal number of shifts.
     * 
     * I've made lots of modifications to attempt to take advantage of the
     * sparse nature of the DCT matrices we're getting.  Although the logic
     * is cumbersome, it's straightforward and the resulting code is much
     * faster.
     *
     * A better way to do this would be to pass in the DCT block as a sparse
     * matrix, perhaps with the difference cases encoded.
     */
    
    #include <memory.h>
    #include "all.h"
    #include "ansi.h"
    #include "dct.h"
    
    
    #define CONST_BITS 13
    
    /*
     * This routine is specialized to the case DCTSIZE = 8.
     */
    
    #if DCTSIZE != 8
      Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
    #endif
    
    
    /*
     * A 2-D IDCT can be done by 1-D IDCT on each row followed by 1-D IDCT
     * on each column.  Direct algorithms are also available, but they are
     * much more complex and seem not to be any faster when reduced to code.
     *
     * The poop on this scaling stuff is as follows:
     *
     * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
     * larger than the true IDCT outputs.  The final outputs are therefore
     * a factor of N larger than desired; since N=8 this can be cured by
     * a simple right shift at the end of the algorithm.  The advantage of
     * this arrangement is that we save two multiplications per 1-D IDCT,
     * because the y0 and y4 inputs need not be divided by sqrt(N).
     *
     * We have to do addition and subtraction of the integer inputs, which
     * is no problem, and multiplication by fractional constants, which is
     * a problem to do in integer arithmetic.  We multiply all the constants
     * by CONST_SCALE and convert them to integer constants (thus retaining
     * CONST_BITS bits of precision in the constants).  After doing a
     * multiplication we have to divide the product by CONST_SCALE, with proper
     * rounding, to produce the correct output.  This division can be done
     * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
     * as long as possible so that partial sums can be added together with
     * full fractional precision.
     *