← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libkdcraw/oneiric-proposed

« back to all changes in this revision

Viewing changes to libraw/demosaic-pack-GPL3/shrtdct_float.c

  • Committer: Bazaar Package Importer
  • Author(s): Philip Muškovac
  • Date: 2011-07-08 09:30:26 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20110708093026-deas159t23p3w3gq
Tags: 4:4.6.90+repack1-0ubuntu1
* New upstream release candidate 
* Update for split packaging

Show diffs side-by-side

added added

removed removed

Lines of Context:
libraw/demosaic-pack-GPL3/shrtdct_float.c
 
1
/*
 
2
Short Discrete Cosine Transform
 
3
    data length :8x8
 
4
    method      :row-column, radix 4 FFT
 
5
functions
 
6
    ddct8x8s  : 8x8 DCT
 
7
function prototypes
 
8
    void ddct8x8s(int isgn, float **a);
 
9
*/
 
10
 
 
11
 
 
12
/*
 
13
-------- 8x8 DCT (Discrete Cosine Transform) / Inverse of DCT --------
 
14
    [definition]
 
15
        <case1> Normalized 8x8 IDCT
 
16
            C[k1][k2] = (1/4) * sum_j1=0^7 sum_j2=0^7
 
17
                            a[j1][j2] * s[j1] * s[j2] *
 
18
                            cos(pi*j1*(k1+1/2)/8) *
 
19
                            cos(pi*j2*(k2+1/2)/8), 0<=k1<8, 0<=k2<8
 
20
                            (s[0] = 1/sqrt(2), s[j] = 1, j > 0)
 
21
        <case2> Normalized 8x8 DCT
 
22
            C[k1][k2] = (1/4) * s[k1] * s[k2] * sum_j1=0^7 sum_j2=0^7
 
23
                            a[j1][j2] *
 
24
                            cos(pi*(j1+1/2)*k1/8) *
 
25
                            cos(pi*(j2+1/2)*k2/8), 0<=k1<8, 0<=k2<8
 
26
                            (s[0] = 1/sqrt(2), s[j] = 1, j > 0)
 
27
    [usage]
 
28
        <case1>
 
29
            ddct8x8s(1, a);
 
30
        <case2>
 
31
            ddct8x8s(-1, a);
 
32
    [parameters]
 
33
        a[0...7][0...7] :input/output data (double **)
 
34
                         output data
 
35
                             a[k1][k2] = C[k1][k2], 0<=k1<8, 0<=k2<8
 
36
*/
 
37
 
 
38
 
 
39
/* Cn_kR = sqrt(2.0/n) * cos(pi/2*k/n) */
 
40
/* Cn_kI = sqrt(2.0/n) * sin(pi/2*k/n) */
 
41
/* Wn_kR = cos(pi/2*k/n) */
 
42
/* Wn_kI = sin(pi/2*k/n) */
 
43
#define C8_1R   0.49039264020161522456
 
44
#define C8_1I   0.09754516100806413392
 
45
#define C8_2R   0.46193976625564337806
 
46
#define C8_2I   0.19134171618254488586
 
47
#define C8_3R   0.41573480615127261854
 
48
#define C8_3I   0.27778511650980111237
 
49
#define C8_4R   0.35355339059327376220
 
50
#define W8_4R   0.70710678118654752440
 
51
 
 
52
 
 
53
void ddct8x8s(int isgn, float **a)
 
54
{
 
55
    int j;
 
56
    float x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
 
57
    float xr, xi;
 
58
 
 
59
    if (isgn < 0) {
 
60
        for (j = 0; j <= 7; j++) {
 
61
            x0r = a[0][j] + a[7][j];
 
62
            x1r = a[0][j] - a[7][j];
 
63
            x0i = a[2][j] + a[5][j];
 
64
            x1i = a[2][j] - a[5][j];
 
65
            x2r = a[4][j] + a[3][j];
 
66
            x3r = a[4][j] - a[3][j];
 
67
            x2i = a[6][j] + a[1][j];
 
68
            x3i = a[6][j] - a[1][j];
 
69
            xr = x0r + x2r;
 
70
            xi = x0i + x2i;
 
71
            a[0][j] = C8_4R * (xr + xi);
 
72
            a[4][j] = C8_4R * (xr - xi);
 
73
            xr = x0r - x2r;
 
74
            xi = x0i - x2i;
 
75
            a[2][j] = C8_2R * xr - C8_2I * xi;
 
76
            a[6][j] = C8_2R * xi + C8_2I * xr;
 
77
            xr = W8_4R * (x1i - x3i);
 
78
            x1i = W8_4R * (x1i + x3i);
 
79
            x3i = x1i - x3r;
 
80
            x1i += x3r;
 
81
            x3r = x1r - xr;
 
82
            x1r += xr;
 
83
            a[1][j] = C8_1R * x1r - C8_1I * x1i;
 
84
            a[7][j] = C8_1R * x1i + C8_1I * x1r;
 
85
            a[3][j] = C8_3R * x3r - C8_3I * x3i;
 
86
            a[5][j] = C8_3R * x3i + C8_3I * x3r;
 
87
        }
 
88
        for (j = 0; j <= 7; j++) {
 
89
            x0r = a[j][0] + a[j][7];
 
90
            x1r = a[j][0] - a[j][7];
 
91
            x0i = a[j][2] + a[j][5];
 
92
            x1i = a[j][2] - a[j][5];
 
93
            x2r = a[j][4] + a[j][3];
 
94
            x3r = a[j][4] - a[j][3];
 
95
            x2i = a[j][6] + a[j][1];
 
96
            x3i = a[j][6] - a[j][1];
 
97
            xr = x0r + x2r;
 
98
            xi = x0i + x2i;
 
99
            a[j][0] = C8_4R * (xr + xi);
 
100
            a[j][4] = C8_4R * (xr - xi);
 
101
            xr = x0r - x2r;
 
102
            xi = x0i - x2i;
 
103
            a[j][2] = C8_2R * xr - C8_2I * xi;
 
104
            a[j][6] = C8_2R * xi + C8_2I * xr;
 
105
            xr = W8_4R * (x1i - x3i);
 
106
            x1i = W8_4R * (x1i + x3i);
 
107
            x3i = x1i - x3r;
 
108
            x1i += x3r;
 
109
            x3r = x1r - xr;
 
110
            x1r += xr;
 
111
            a[j][1] = C8_1R * x1r - C8_1I * x1i;
 
112
            a[j][7] = C8_1R * x1i + C8_1I * x1r;
 
113
            a[j][3] = C8_3R * x3r - C8_3I * x3i;
 
114
            a[j][5] = C8_3R * x3i + C8_3I * x3r;
 
115
        }
 
116
    } else {
 
117
        for (j = 0; j <= 7; j++) {
 
118
            x1r = C8_1R * a[1][j] + C8_1I * a[7][j];
 
119
            x1i = C8_1R * a[7][j] - C8_1I * a[1][j];
 
120
            x3r = C8_3R * a[3][j] + C8_3I * a[5][j];
 
121
            x3i = C8_3R * a[5][j] - C8_3I * a[3][j];
 
122
            xr = x1r - x3r;
 
123
            xi = x1i + x3i;
 
124
            x1r += x3r;
 
125
            x3i -= x1i;
 
126
            x1i = W8_4R * (xr + xi);
 
127
            x3r = W8_4R * (xr - xi);
 
128
            xr = C8_2R * a[2][j] + C8_2I * a[6][j];
 
129
            xi = C8_2R * a[6][j] - C8_2I * a[2][j];
 
130
            x0r = C8_4R * (a[0][j] + a[4][j]);
 
131
            x0i = C8_4R * (a[0][j] - a[4][j]);
 
132
            x2r = x0r - xr;
 
133
            x2i = x0i - xi;
 
134
            x0r += xr;
 
135
            x0i += xi;
 
136
            a[0][j] = x0r + x1r;
 
137
            a[7][j] = x0r - x1r;
 
138
            a[2][j] = x0i + x1i;
 
139
            a[5][j] = x0i - x1i;
 
140
            a[4][j] = x2r - x3i;
 
141
            a[3][j] = x2r + x3i;
 
142
            a[6][j] = x2i - x3r;
 
143
            a[1][j] = x2i + x3r;
 
144
        }
 
145
        for (j = 0; j <= 7; j++) {
 
146
            x1r = C8_1R * a[j][1] + C8_1I * a[j][7];
 
147
            x1i = C8_1R * a[j][7] - C8_1I * a[j][1];
 
148
            x3r = C8_3R * a[j][3] + C8_3I * a[j][5];
 
149
            x3i = C8_3R * a[j][5] - C8_3I * a[j][3];
 
150
            xr = x1r - x3r;
 
151
            xi = x1i + x3i;
 
152
            x1r += x3r;
 
153
            x3i -= x1i;
 
154
            x1i = W8_4R * (xr + xi);
 
155
            x3r = W8_4R * (xr - xi);
 
156
            xr = C8_2R * a[j][2] + C8_2I * a[j][6];
 
157
            xi = C8_2R * a[j][6] - C8_2I * a[j][2];
 
158
            x0r = C8_4R * (a[j][0] + a[j][4]);
 
159
            x0i = C8_4R * (a[j][0] - a[j][4]);
 
160
            x2r = x0r - xr;
 
161
            x2i = x0i - xi;
 
162
            x0r += xr;
 
163
            x0i += xi;
 
164
            a[j][0] = x0r + x1r;
 
165
            a[j][7] = x0r - x1r;
 
166
            a[j][2] = x0i + x1i;
 
167
            a[j][5] = x0i - x1i;
 
168
            a[j][4] = x2r - x3i;
 
169
            a[j][3] = x2r + x3i;
 
170
            a[j][6] = x2i - x3r;
 
171
            a[j][1] = x2i + x3r;
 
172
        }
 
173
    }
 
174
}
 
175