/src/libvpx/vp8/common/idctllm.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) 2010 The WebM project authors. All Rights Reserved. |
3 | | * |
4 | | * Use of this source code is governed by a BSD-style license |
5 | | * that can be found in the LICENSE file in the root of the source |
6 | | * tree. An additional intellectual property rights grant can be found |
7 | | * in the file PATENTS. All contributing project authors may |
8 | | * be found in the AUTHORS file in the root of the source tree. |
9 | | */ |
10 | | |
11 | | #include "./vp8_rtcd.h" |
12 | | |
13 | | /**************************************************************************** |
14 | | * Notes: |
15 | | * |
16 | | * This implementation makes use of 16 bit fixed point verio of two multiply |
17 | | * constants: |
18 | | * 1. sqrt(2) * cos (pi/8) |
19 | | * 2. sqrt(2) * sin (pi/8) |
20 | | * Becuase the first constant is bigger than 1, to maintain the same 16 bit |
21 | | * fixed point precision as the second one, we use a trick of |
22 | | * x * a = x + x*(a-1) |
23 | | * so |
24 | | * x * sqrt(2) * cos (pi/8) = x + x * (sqrt(2) *cos(pi/8)-1). |
25 | | **************************************************************************/ |
26 | | static const int cospi8sqrt2minus1 = 20091; |
27 | | static const int sinpi8sqrt2 = 35468; |
28 | | |
29 | | void vp8_short_idct4x4llm_c(short *input, unsigned char *pred_ptr, |
30 | | int pred_stride, unsigned char *dst_ptr, |
31 | 0 | int dst_stride) { |
32 | 0 | int i; |
33 | 0 | int r, c; |
34 | 0 | int a1, b1, c1, d1; |
35 | 0 | short output[16]; |
36 | 0 | short *ip = input; |
37 | 0 | short *op = output; |
38 | 0 | int temp1, temp2; |
39 | 0 | int shortpitch = 4; |
40 | |
|
41 | 0 | for (i = 0; i < 4; ++i) { |
42 | 0 | a1 = ip[0] + ip[8]; |
43 | 0 | b1 = ip[0] - ip[8]; |
44 | |
|
45 | 0 | temp1 = (ip[4] * sinpi8sqrt2) >> 16; |
46 | 0 | temp2 = ip[12] + ((ip[12] * cospi8sqrt2minus1) >> 16); |
47 | 0 | c1 = temp1 - temp2; |
48 | |
|
49 | 0 | temp1 = ip[4] + ((ip[4] * cospi8sqrt2minus1) >> 16); |
50 | 0 | temp2 = (ip[12] * sinpi8sqrt2) >> 16; |
51 | 0 | d1 = temp1 + temp2; |
52 | |
|
53 | 0 | op[shortpitch * 0] = a1 + d1; |
54 | 0 | op[shortpitch * 3] = a1 - d1; |
55 | |
|
56 | 0 | op[shortpitch * 1] = b1 + c1; |
57 | 0 | op[shortpitch * 2] = b1 - c1; |
58 | |
|
59 | 0 | ip++; |
60 | 0 | op++; |
61 | 0 | } |
62 | |
|
63 | 0 | ip = output; |
64 | 0 | op = output; |
65 | |
|
66 | 0 | for (i = 0; i < 4; ++i) { |
67 | 0 | a1 = ip[0] + ip[2]; |
68 | 0 | b1 = ip[0] - ip[2]; |
69 | |
|
70 | 0 | temp1 = (ip[1] * sinpi8sqrt2) >> 16; |
71 | 0 | temp2 = ip[3] + ((ip[3] * cospi8sqrt2minus1) >> 16); |
72 | 0 | c1 = temp1 - temp2; |
73 | |
|
74 | 0 | temp1 = ip[1] + ((ip[1] * cospi8sqrt2minus1) >> 16); |
75 | 0 | temp2 = (ip[3] * sinpi8sqrt2) >> 16; |
76 | 0 | d1 = temp1 + temp2; |
77 | |
|
78 | 0 | op[0] = (a1 + d1 + 4) >> 3; |
79 | 0 | op[3] = (a1 - d1 + 4) >> 3; |
80 | |
|
81 | 0 | op[1] = (b1 + c1 + 4) >> 3; |
82 | 0 | op[2] = (b1 - c1 + 4) >> 3; |
83 | |
|
84 | 0 | ip += shortpitch; |
85 | 0 | op += shortpitch; |
86 | 0 | } |
87 | |
|
88 | 0 | ip = output; |
89 | 0 | for (r = 0; r < 4; ++r) { |
90 | 0 | for (c = 0; c < 4; ++c) { |
91 | 0 | int a = ip[c] + pred_ptr[c]; |
92 | |
|
93 | 0 | if (a < 0) a = 0; |
94 | |
|
95 | 0 | if (a > 255) a = 255; |
96 | |
|
97 | 0 | dst_ptr[c] = (unsigned char)a; |
98 | 0 | } |
99 | 0 | ip += 4; |
100 | 0 | dst_ptr += dst_stride; |
101 | 0 | pred_ptr += pred_stride; |
102 | 0 | } |
103 | 0 | } |
104 | | |
105 | | void vp8_dc_only_idct_add_c(short input_dc, unsigned char *pred_ptr, |
106 | | int pred_stride, unsigned char *dst_ptr, |
107 | 0 | int dst_stride) { |
108 | 0 | int a1 = ((input_dc + 4) >> 3); |
109 | 0 | int r, c; |
110 | |
|
111 | 0 | for (r = 0; r < 4; ++r) { |
112 | 0 | for (c = 0; c < 4; ++c) { |
113 | 0 | int a = a1 + pred_ptr[c]; |
114 | |
|
115 | 0 | if (a < 0) a = 0; |
116 | |
|
117 | 0 | if (a > 255) a = 255; |
118 | |
|
119 | 0 | dst_ptr[c] = (unsigned char)a; |
120 | 0 | } |
121 | |
|
122 | 0 | dst_ptr += dst_stride; |
123 | 0 | pred_ptr += pred_stride; |
124 | 0 | } |
125 | 0 | } |
126 | | |
127 | 0 | void vp8_short_inv_walsh4x4_c(short *input, short *mb_dqcoeff) { |
128 | 0 | short output[16]; |
129 | 0 | int i; |
130 | 0 | int a1, b1, c1, d1; |
131 | 0 | int a2, b2, c2, d2; |
132 | 0 | short *ip = input; |
133 | 0 | short *op = output; |
134 | |
|
135 | 0 | for (i = 0; i < 4; ++i) { |
136 | 0 | a1 = ip[0] + ip[12]; |
137 | 0 | b1 = ip[4] + ip[8]; |
138 | 0 | c1 = ip[4] - ip[8]; |
139 | 0 | d1 = ip[0] - ip[12]; |
140 | |
|
141 | 0 | op[0] = a1 + b1; |
142 | 0 | op[4] = c1 + d1; |
143 | 0 | op[8] = a1 - b1; |
144 | 0 | op[12] = d1 - c1; |
145 | 0 | ip++; |
146 | 0 | op++; |
147 | 0 | } |
148 | |
|
149 | 0 | ip = output; |
150 | 0 | op = output; |
151 | |
|
152 | 0 | for (i = 0; i < 4; ++i) { |
153 | 0 | a1 = ip[0] + ip[3]; |
154 | 0 | b1 = ip[1] + ip[2]; |
155 | 0 | c1 = ip[1] - ip[2]; |
156 | 0 | d1 = ip[0] - ip[3]; |
157 | |
|
158 | 0 | a2 = a1 + b1; |
159 | 0 | b2 = c1 + d1; |
160 | 0 | c2 = a1 - b1; |
161 | 0 | d2 = d1 - c1; |
162 | |
|
163 | 0 | op[0] = (a2 + 3) >> 3; |
164 | 0 | op[1] = (b2 + 3) >> 3; |
165 | 0 | op[2] = (c2 + 3) >> 3; |
166 | 0 | op[3] = (d2 + 3) >> 3; |
167 | |
|
168 | 0 | ip += 4; |
169 | 0 | op += 4; |
170 | 0 | } |
171 | |
|
172 | 0 | for (i = 0; i < 16; ++i) { |
173 | 0 | mb_dqcoeff[i * 16] = output[i]; |
174 | 0 | } |
175 | 0 | } |
176 | | |
177 | 804k | void vp8_short_inv_walsh4x4_1_c(short *input, short *mb_dqcoeff) { |
178 | 804k | int i; |
179 | 804k | int a1; |
180 | | |
181 | 804k | a1 = ((input[0] + 3) >> 3); |
182 | 13.6M | for (i = 0; i < 16; ++i) { |
183 | 12.8M | mb_dqcoeff[i * 16] = a1; |
184 | 12.8M | } |
185 | 804k | } |