istereo2

annotate libs/libjpeg/jfdctflt.c @ 4:d4fed8aac9a6

find changesets by author, revision, files, or words in the commit message
fixed all sideways crap in the effect code fixed fov on all orientations fixed inverted tangent vector in bump mapped version
author John Tsiombikas <nuclear@member.fsf.org>
date Mon, 21 Sep 2015 21:12:36 +0300
parents
children
rev   line source
nuclear@2 1 /*
nuclear@2 2 * jfdctflt.c
nuclear@2 3 *
nuclear@2 4 * Copyright (C) 1994-1996, Thomas G. Lane.
nuclear@2 5 * This file is part of the Independent JPEG Group's software.
nuclear@2 6 * For conditions of distribution and use, see the accompanying README file.
nuclear@2 7 *
nuclear@2 8 * This file contains a floating-point implementation of the
nuclear@2 9 * forward DCT (Discrete Cosine Transform).
nuclear@2 10 *
nuclear@2 11 * This implementation should be more accurate than either of the integer
nuclear@2 12 * DCT implementations. However, it may not give the same results on all
nuclear@2 13 * machines because of differences in roundoff behavior. Speed will depend
nuclear@2 14 * on the hardware's floating point capacity.
nuclear@2 15 *
nuclear@2 16 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
nuclear@2 17 * on each column. Direct algorithms are also available, but they are
nuclear@2 18 * much more complex and seem not to be any faster when reduced to code.
nuclear@2 19 *
nuclear@2 20 * This implementation is based on Arai, Agui, and Nakajima's algorithm for
nuclear@2 21 * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
nuclear@2 22 * Japanese, but the algorithm is described in the Pennebaker & Mitchell
nuclear@2 23 * JPEG textbook (see REFERENCES section in file README). The following code
nuclear@2 24 * is based directly on figure 4-8 in P&M.
nuclear@2 25 * While an 8-point DCT cannot be done in less than 11 multiplies, it is
nuclear@2 26 * possible to arrange the computation so that many of the multiplies are
nuclear@2 27 * simple scalings of the final outputs. These multiplies can then be
nuclear@2 28 * folded into the multiplications or divisions by the JPEG quantization
nuclear@2 29 * table entries. The AA&N method leaves only 5 multiplies and 29 adds
nuclear@2 30 * to be done in the DCT itself.
nuclear@2 31 * The primary disadvantage of this method is that with a fixed-point
nuclear@2 32 * implementation, accuracy is lost due to imprecise representation of the
nuclear@2 33 * scaled quantization values. However, that problem does not arise if
nuclear@2 34 * we use floating point arithmetic.
nuclear@2 35 */
nuclear@2 36
nuclear@2 37 #define JPEG_INTERNALS
nuclear@2 38 #include "jinclude.h"
nuclear@2 39 #include "jpeglib.h"
nuclear@2 40 #include "jdct.h" /* Private declarations for DCT subsystem */
nuclear@2 41
nuclear@2 42 #ifdef DCT_FLOAT_SUPPORTED
nuclear@2 43
nuclear@2 44
nuclear@2 45 /*
nuclear@2 46 * This module is specialized to the case DCTSIZE = 8.
nuclear@2 47 */
nuclear@2 48
nuclear@2 49 #if DCTSIZE != 8
nuclear@2 50 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
nuclear@2 51 #endif
nuclear@2 52
nuclear@2 53
nuclear@2 54 /*
nuclear@2 55 * Perform the forward DCT on one block of samples.
nuclear@2 56 */
nuclear@2 57
nuclear@2 58 GLOBAL(void)
nuclear@2 59 jpeg_fdct_float (FAST_FLOAT * data)
nuclear@2 60 {
nuclear@2 61 FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
nuclear@2 62 FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
nuclear@2 63 FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
nuclear@2 64 FAST_FLOAT *dataptr;
nuclear@2 65 int ctr;
nuclear@2 66
nuclear@2 67 /* Pass 1: process rows. */
nuclear@2 68
nuclear@2 69 dataptr = data;
nuclear@2 70 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
nuclear@2 71 tmp0 = dataptr[0] + dataptr[7];
nuclear@2 72 tmp7 = dataptr[0] - dataptr[7];
nuclear@2 73 tmp1 = dataptr[1] + dataptr[6];
nuclear@2 74 tmp6 = dataptr[1] - dataptr[6];
nuclear@2 75 tmp2 = dataptr[2] + dataptr[5];
nuclear@2 76 tmp5 = dataptr[2] - dataptr[5];
nuclear@2 77 tmp3 = dataptr[3] + dataptr[4];
nuclear@2 78 tmp4 = dataptr[3] - dataptr[4];
nuclear@2 79
nuclear@2 80 /* Even part */
nuclear@2 81
nuclear@2 82 tmp10 = tmp0 + tmp3; /* phase 2 */
nuclear@2 83 tmp13 = tmp0 - tmp3;
nuclear@2 84 tmp11 = tmp1 + tmp2;
nuclear@2 85 tmp12 = tmp1 - tmp2;
nuclear@2 86
nuclear@2 87 dataptr[0] = tmp10 + tmp11; /* phase 3 */
nuclear@2 88 dataptr[4] = tmp10 - tmp11;
nuclear@2 89
nuclear@2 90 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
nuclear@2 91 dataptr[2] = tmp13 + z1; /* phase 5 */
nuclear@2 92 dataptr[6] = tmp13 - z1;
nuclear@2 93
nuclear@2 94 /* Odd part */
nuclear@2 95
nuclear@2 96 tmp10 = tmp4 + tmp5; /* phase 2 */
nuclear@2 97 tmp11 = tmp5 + tmp6;
nuclear@2 98 tmp12 = tmp6 + tmp7;
nuclear@2 99
nuclear@2 100 /* The rotator is modified from fig 4-8 to avoid extra negations. */
nuclear@2 101 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
nuclear@2 102 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
nuclear@2 103 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
nuclear@2 104 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
nuclear@2 105
nuclear@2 106 z11 = tmp7 + z3; /* phase 5 */
nuclear@2 107 z13 = tmp7 - z3;
nuclear@2 108
nuclear@2 109 dataptr[5] = z13 + z2; /* phase 6 */
nuclear@2 110 dataptr[3] = z13 - z2;
nuclear@2 111 dataptr[1] = z11 + z4;
nuclear@2 112 dataptr[7] = z11 - z4;
nuclear@2 113
nuclear@2 114 dataptr += DCTSIZE; /* advance pointer to next row */
nuclear@2 115 }
nuclear@2 116
nuclear@2 117 /* Pass 2: process columns. */
nuclear@2 118
nuclear@2 119 dataptr = data;
nuclear@2 120 for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
nuclear@2 121 tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
nuclear@2 122 tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
nuclear@2 123 tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
nuclear@2 124 tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
nuclear@2 125 tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
nuclear@2 126 tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
nuclear@2 127 tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
nuclear@2 128 tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
nuclear@2 129
nuclear@2 130 /* Even part */
nuclear@2 131
nuclear@2 132 tmp10 = tmp0 + tmp3; /* phase 2 */
nuclear@2 133 tmp13 = tmp0 - tmp3;
nuclear@2 134 tmp11 = tmp1 + tmp2;
nuclear@2 135 tmp12 = tmp1 - tmp2;
nuclear@2 136
nuclear@2 137 dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
nuclear@2 138 dataptr[DCTSIZE*4] = tmp10 - tmp11;
nuclear@2 139
nuclear@2 140 z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
nuclear@2 141 dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
nuclear@2 142 dataptr[DCTSIZE*6] = tmp13 - z1;
nuclear@2 143
nuclear@2 144 /* Odd part */
nuclear@2 145
nuclear@2 146 tmp10 = tmp4 + tmp5; /* phase 2 */
nuclear@2 147 tmp11 = tmp5 + tmp6;
nuclear@2 148 tmp12 = tmp6 + tmp7;
nuclear@2 149
nuclear@2 150 /* The rotator is modified from fig 4-8 to avoid extra negations. */
nuclear@2 151 z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
nuclear@2 152 z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
nuclear@2 153 z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
nuclear@2 154 z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
nuclear@2 155
nuclear@2 156 z11 = tmp7 + z3; /* phase 5 */
nuclear@2 157 z13 = tmp7 - z3;
nuclear@2 158
nuclear@2 159 dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
nuclear@2 160 dataptr[DCTSIZE*3] = z13 - z2;
nuclear@2 161 dataptr[DCTSIZE*1] = z11 + z4;
nuclear@2 162 dataptr[DCTSIZE*7] = z11 - z4;
nuclear@2 163
nuclear@2 164 dataptr++; /* advance pointer to next column */
nuclear@2 165 }
nuclear@2 166 }
nuclear@2 167
nuclear@2 168 #endif /* DCT_FLOAT_SUPPORTED */