1 /* |
|
2 * Copyright (c) 2010 Ixonos Plc. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Ixonos Plc |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 #include "globals.h" |
|
21 #include "invtransform.h" |
|
22 |
|
23 |
|
24 #ifndef AVC_RECO_BLOCK_ASM |
|
25 |
|
26 /* |
|
27 * |
|
28 * itrIDCTdequant4x4: |
|
29 * |
|
30 * Parameters: |
|
31 * src Source values |
|
32 * dest Inverse transformed values |
|
33 * dequantPtr Dequant coefficients |
|
34 * qp_per qp/6 |
|
35 * isDc True if DC is separate |
|
36 * dcValue Possible DC value |
|
37 * |
|
38 * Function: |
|
39 * Dequantize coefficients and compute approximate 4x4 inverse DCT. |
|
40 * |
|
41 * Returns: |
|
42 * - |
|
43 */ |
|
44 void itrIDCTdequant4x4(int src[4][4], int dest[4][4], const int *dequantPtr, |
|
45 int qp_per, int isDc, int dcValue) |
|
46 { |
|
47 int tmp[4][4]; |
|
48 int A, B, C, D, E, F; |
|
49 int i; |
|
50 int deqc; |
|
51 |
|
52 /* |
|
53 * a = A + B + C + (D>>1) |
|
54 * b = A + (B>>1) - C - D |
|
55 * c = A - (B>>1) - C + D |
|
56 * d = A - B + C - (D>>1) |
|
57 * => |
|
58 * E = A + C |
|
59 * F = B + (D>>1) |
|
60 * a = E + F |
|
61 * d = E - F |
|
62 * E = A - C |
|
63 * F = (B>>1) - D |
|
64 * b = E + F |
|
65 * c = E - F |
|
66 */ |
|
67 |
|
68 A = dcValue; |
|
69 |
|
70 for (i = 0; i < 4; i++) { |
|
71 deqc = (*dequantPtr++) << qp_per; |
|
72 |
|
73 if (!isDc) |
|
74 A = src[i][0] * deqc; |
|
75 |
|
76 C = src[i][2] * deqc; |
|
77 |
|
78 deqc = (*dequantPtr++) << qp_per; |
|
79 |
|
80 B = src[i][1] * deqc; |
|
81 D = src[i][3] * deqc; |
|
82 |
|
83 E = A + C; |
|
84 F = B + (D>>1); |
|
85 tmp[i][0] = E + F; |
|
86 tmp[i][3] = E - F; |
|
87 E = A - C; |
|
88 F = (B>>1) - D; |
|
89 tmp[i][1] = E + F; |
|
90 tmp[i][2] = E - F; |
|
91 |
|
92 isDc = 0; |
|
93 } |
|
94 |
|
95 for (i = 0; i < 4; i++) { |
|
96 E = tmp[0][i] + tmp[2][i]; |
|
97 F = tmp[1][i] + (tmp[3][i]>>1); |
|
98 dest[0][i] = E + F; |
|
99 dest[3][i] = E - F; |
|
100 E = tmp[0][i] - tmp[2][i]; |
|
101 F = (tmp[1][i]>>1) - tmp[3][i]; |
|
102 dest[1][i] = E + F; |
|
103 dest[2][i] = E - F; |
|
104 } |
|
105 } |
|
106 |
|
107 #endif |
|
108 |
|
109 |
|
110 /* |
|
111 * |
|
112 * itrIHadaDequant4x4: |
|
113 * |
|
114 * Parameters: |
|
115 * src Source values |
|
116 * dest Inverse transformed values |
|
117 * deqc Dequantization coefficient |
|
118 * |
|
119 * Function: |
|
120 * Compute 4x4 inverse Hadamard transform and dequantize coefficients. |
|
121 * |
|
122 * Returns: |
|
123 * - |
|
124 * |
|
125 */ |
|
126 void itrIHadaDequant4x4(int src[4][4], int dest[4][4], int deqc) |
|
127 { |
|
128 int tmp[4][4]; |
|
129 int E; |
|
130 int F; |
|
131 int i; |
|
132 |
|
133 for (i = 0; i < 4; i++) { |
|
134 E = src[i][0] + src[i][2]; |
|
135 F = src[i][1] + src[i][3]; |
|
136 tmp[i][0] = E + F; |
|
137 tmp[i][3] = E - F; |
|
138 E = src[i][0] - src[i][2]; |
|
139 F = src[i][1] - src[i][3]; |
|
140 tmp[i][1] = E + F; |
|
141 tmp[i][2] = E - F; |
|
142 } |
|
143 |
|
144 for (i = 0; i < 4; i++) { |
|
145 E = tmp[0][i] + tmp[2][i]; |
|
146 F = tmp[1][i] + tmp[3][i]; |
|
147 dest[0][i] = ((E + F) * deqc + 2) >> 2; |
|
148 dest[3][i] = ((E - F) * deqc + 2) >> 2; |
|
149 E = tmp[0][i] - tmp[2][i]; |
|
150 F = tmp[1][i] - tmp[3][i]; |
|
151 dest[1][i] = ((E + F) * deqc + 2) >> 2; |
|
152 dest[2][i] = ((E - F) * deqc + 2) >> 2; |
|
153 } |
|
154 } |
|
155 |
|
156 |
|
157 /* |
|
158 * |
|
159 * itrIDCTdequant2x2: |
|
160 * |
|
161 * Parameters: |
|
162 * src Source values |
|
163 * dest Inverse transformed values |
|
164 * deqc Dequantization coefficient |
|
165 * |
|
166 * Function: |
|
167 * Compute 2x2 inverse DCT and dequantize coefficients. |
|
168 * |
|
169 * Returns: |
|
170 * - |
|
171 * |
|
172 */ |
|
173 void itrIDCTdequant2x2(int src[2][2], int dest[2][2], int deqc) |
|
174 { |
|
175 int DDC00 = src[0][0]; |
|
176 int DDC10 = src[0][1]; |
|
177 int DDC01 = src[1][0]; |
|
178 int DDC11 = src[1][1]; |
|
179 int A, B; |
|
180 |
|
181 /* |
|
182 * DDC(0,0) DDC(1,0) => DC0 DC1 |
|
183 * DDC(0,1) DDC(1,1) DC2 DC3 |
|
184 * |
|
185 * DC0 = (DDC00+DDC10+DDC01+DDC11) |
|
186 * DC1 = (DDC00-DDC10+DDC01-DDC11) |
|
187 * DC2 = (DDC00+DDC10-DDC01-DDC11) |
|
188 * DC3 = (DDC00-DDC10-DDC01+DDC11) |
|
189 */ |
|
190 |
|
191 A = DDC00 + DDC01; |
|
192 B = DDC10 + DDC11; |
|
193 dest[0][0] = ((A + B) * deqc) >> 1; |
|
194 dest[0][1] = ((A - B) * deqc) >> 1; |
|
195 A = DDC00 - DDC01; |
|
196 B = DDC10 - DDC11; |
|
197 dest[1][0] = ((A + B) * deqc) >> 1; |
|
198 dest[1][1] = ((A - B) * deqc) >> 1; |
|
199 } |
|