...
Run Format

Source file src/image/jpeg/idct.go

Documentation: image/jpeg

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package jpeg
     6  
     7  // This is a Go translation of idct.c from
     8  //
     9  // http://standards.iso.org/ittf/PubliclyAvailableStandards/ISO_IEC_13818-4_2004_Conformance_Testing/Video/verifier/mpeg2decode_960109.tar.gz
    10  //
    11  // which carries the following notice:
    12  
    13  /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
    14  
    15  /*
    16   * Disclaimer of Warranty
    17   *
    18   * These software programs are available to the user without any license fee or
    19   * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
    20   * any and all warranties, whether express, implied, or statuary, including any
    21   * implied warranties or merchantability or of fitness for a particular
    22   * purpose.  In no event shall the copyright-holder be liable for any
    23   * incidental, punitive, or consequential damages of any kind whatsoever
    24   * arising from the use of these programs.
    25   *
    26   * This disclaimer of warranty extends to the user of these programs and user's
    27   * customers, employees, agents, transferees, successors, and assigns.
    28   *
    29   * The MPEG Software Simulation Group does not represent or warrant that the
    30   * programs furnished hereunder are free of infringement of any third-party
    31   * patents.
    32   *
    33   * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
    34   * are subject to royalty fees to patent holders.  Many of these patents are
    35   * general enough such that they are unavoidable regardless of implementation
    36   * design.
    37   *
    38   */
    39  
    40  const blockSize = 64 // A DCT block is 8x8.
    41  
    42  type block [blockSize]int32
    43  
    44  const (
    45  	w1 = 2841 // 2048*sqrt(2)*cos(1*pi/16)
    46  	w2 = 2676 // 2048*sqrt(2)*cos(2*pi/16)
    47  	w3 = 2408 // 2048*sqrt(2)*cos(3*pi/16)
    48  	w5 = 1609 // 2048*sqrt(2)*cos(5*pi/16)
    49  	w6 = 1108 // 2048*sqrt(2)*cos(6*pi/16)
    50  	w7 = 565  // 2048*sqrt(2)*cos(7*pi/16)
    51  
    52  	w1pw7 = w1 + w7
    53  	w1mw7 = w1 - w7
    54  	w2pw6 = w2 + w6
    55  	w2mw6 = w2 - w6
    56  	w3pw5 = w3 + w5
    57  	w3mw5 = w3 - w5
    58  
    59  	r2 = 181 // 256/sqrt(2)
    60  )
    61  
    62  // idct performs a 2-D Inverse Discrete Cosine Transformation.
    63  //
    64  // The input coefficients should already have been multiplied by the
    65  // appropriate quantization table. We use fixed-point computation, with the
    66  // number of bits for the fractional component varying over the intermediate
    67  // stages.
    68  //
    69  // For more on the actual algorithm, see Z. Wang, "Fast algorithms for the
    70  // discrete W transform and for the discrete Fourier transform", IEEE Trans. on
    71  // ASSP, Vol. ASSP- 32, pp. 803-816, Aug. 1984.
    72  func idct(src *block) {
    73  	// Horizontal 1-D IDCT.
    74  	for y := 0; y < 8; y++ {
    75  		y8 := y * 8
    76  		// If all the AC components are zero, then the IDCT is trivial.
    77  		if src[y8+1] == 0 && src[y8+2] == 0 && src[y8+3] == 0 &&
    78  			src[y8+4] == 0 && src[y8+5] == 0 && src[y8+6] == 0 && src[y8+7] == 0 {
    79  			dc := src[y8+0] << 3
    80  			src[y8+0] = dc
    81  			src[y8+1] = dc
    82  			src[y8+2] = dc
    83  			src[y8+3] = dc
    84  			src[y8+4] = dc
    85  			src[y8+5] = dc
    86  			src[y8+6] = dc
    87  			src[y8+7] = dc
    88  			continue
    89  		}
    90  
    91  		// Prescale.
    92  		x0 := (src[y8+0] << 11) + 128
    93  		x1 := src[y8+4] << 11
    94  		x2 := src[y8+6]
    95  		x3 := src[y8+2]
    96  		x4 := src[y8+1]
    97  		x5 := src[y8+7]
    98  		x6 := src[y8+5]
    99  		x7 := src[y8+3]
   100  
   101  		// Stage 1.
   102  		x8 := w7 * (x4 + x5)
   103  		x4 = x8 + w1mw7*x4
   104  		x5 = x8 - w1pw7*x5
   105  		x8 = w3 * (x6 + x7)
   106  		x6 = x8 - w3mw5*x6
   107  		x7 = x8 - w3pw5*x7
   108  
   109  		// Stage 2.
   110  		x8 = x0 + x1
   111  		x0 -= x1
   112  		x1 = w6 * (x3 + x2)
   113  		x2 = x1 - w2pw6*x2
   114  		x3 = x1 + w2mw6*x3
   115  		x1 = x4 + x6
   116  		x4 -= x6
   117  		x6 = x5 + x7
   118  		x5 -= x7
   119  
   120  		// Stage 3.
   121  		x7 = x8 + x3
   122  		x8 -= x3
   123  		x3 = x0 + x2
   124  		x0 -= x2
   125  		x2 = (r2*(x4+x5) + 128) >> 8
   126  		x4 = (r2*(x4-x5) + 128) >> 8
   127  
   128  		// Stage 4.
   129  		src[y8+0] = (x7 + x1) >> 8
   130  		src[y8+1] = (x3 + x2) >> 8
   131  		src[y8+2] = (x0 + x4) >> 8
   132  		src[y8+3] = (x8 + x6) >> 8
   133  		src[y8+4] = (x8 - x6) >> 8
   134  		src[y8+5] = (x0 - x4) >> 8
   135  		src[y8+6] = (x3 - x2) >> 8
   136  		src[y8+7] = (x7 - x1) >> 8
   137  	}
   138  
   139  	// Vertical 1-D IDCT.
   140  	for x := 0; x < 8; x++ {
   141  		// Similar to the horizontal 1-D IDCT case, if all the AC components are zero, then the IDCT is trivial.
   142  		// However, after performing the horizontal 1-D IDCT, there are typically non-zero AC components, so
   143  		// we do not bother to check for the all-zero case.
   144  
   145  		// Prescale.
   146  		y0 := (src[8*0+x] << 8) + 8192
   147  		y1 := src[8*4+x] << 8
   148  		y2 := src[8*6+x]
   149  		y3 := src[8*2+x]
   150  		y4 := src[8*1+x]
   151  		y5 := src[8*7+x]
   152  		y6 := src[8*5+x]
   153  		y7 := src[8*3+x]
   154  
   155  		// Stage 1.
   156  		y8 := w7*(y4+y5) + 4
   157  		y4 = (y8 + w1mw7*y4) >> 3
   158  		y5 = (y8 - w1pw7*y5) >> 3
   159  		y8 = w3*(y6+y7) + 4
   160  		y6 = (y8 - w3mw5*y6) >> 3
   161  		y7 = (y8 - w3pw5*y7) >> 3
   162  
   163  		// Stage 2.
   164  		y8 = y0 + y1
   165  		y0 -= y1
   166  		y1 = w6*(y3+y2) + 4
   167  		y2 = (y1 - w2pw6*y2) >> 3
   168  		y3 = (y1 + w2mw6*y3) >> 3
   169  		y1 = y4 + y6
   170  		y4 -= y6
   171  		y6 = y5 + y7
   172  		y5 -= y7
   173  
   174  		// Stage 3.
   175  		y7 = y8 + y3
   176  		y8 -= y3
   177  		y3 = y0 + y2
   178  		y0 -= y2
   179  		y2 = (r2*(y4+y5) + 128) >> 8
   180  		y4 = (r2*(y4-y5) + 128) >> 8
   181  
   182  		// Stage 4.
   183  		src[8*0+x] = (y7 + y1) >> 14
   184  		src[8*1+x] = (y3 + y2) >> 14
   185  		src[8*2+x] = (y0 + y4) >> 14
   186  		src[8*3+x] = (y8 + y6) >> 14
   187  		src[8*4+x] = (y8 - y6) >> 14
   188  		src[8*5+x] = (y0 - y4) >> 14
   189  		src[8*6+x] = (y3 - y2) >> 14
   190  		src[8*7+x] = (y7 - y1) >> 14
   191  	}
   192  }
   193  

View as plain text