Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/me_cmp.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 411 | 567 | 72.5% |
Branches: | 101 | 163 | 62.0% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * DSP utils | ||
3 | * Copyright (c) 2000, 2001 Fabrice Bellard | ||
4 | * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> | ||
5 | * | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | #include "libavutil/attributes.h" | ||
24 | #include "libavutil/internal.h" | ||
25 | #include "libavutil/mem_internal.h" | ||
26 | #include "avcodec.h" | ||
27 | #include "copy_block.h" | ||
28 | #include "simple_idct.h" | ||
29 | #include "me_cmp.h" | ||
30 | #include "mpegvideoenc.h" | ||
31 | #include "config.h" | ||
32 | #include "config_components.h" | ||
33 | |||
34 | /* (i - 256) * (i - 256) */ | ||
35 | const uint32_t ff_square_tab[512] = { | ||
36 | 65536, 65025, 64516, 64009, 63504, 63001, 62500, 62001, 61504, 61009, 60516, 60025, 59536, 59049, 58564, 58081, | ||
37 | 57600, 57121, 56644, 56169, 55696, 55225, 54756, 54289, 53824, 53361, 52900, 52441, 51984, 51529, 51076, 50625, | ||
38 | 50176, 49729, 49284, 48841, 48400, 47961, 47524, 47089, 46656, 46225, 45796, 45369, 44944, 44521, 44100, 43681, | ||
39 | 43264, 42849, 42436, 42025, 41616, 41209, 40804, 40401, 40000, 39601, 39204, 38809, 38416, 38025, 37636, 37249, | ||
40 | 36864, 36481, 36100, 35721, 35344, 34969, 34596, 34225, 33856, 33489, 33124, 32761, 32400, 32041, 31684, 31329, | ||
41 | 30976, 30625, 30276, 29929, 29584, 29241, 28900, 28561, 28224, 27889, 27556, 27225, 26896, 26569, 26244, 25921, | ||
42 | 25600, 25281, 24964, 24649, 24336, 24025, 23716, 23409, 23104, 22801, 22500, 22201, 21904, 21609, 21316, 21025, | ||
43 | 20736, 20449, 20164, 19881, 19600, 19321, 19044, 18769, 18496, 18225, 17956, 17689, 17424, 17161, 16900, 16641, | ||
44 | 16384, 16129, 15876, 15625, 15376, 15129, 14884, 14641, 14400, 14161, 13924, 13689, 13456, 13225, 12996, 12769, | ||
45 | 12544, 12321, 12100, 11881, 11664, 11449, 11236, 11025, 10816, 10609, 10404, 10201, 10000, 9801, 9604, 9409, | ||
46 | 9216, 9025, 8836, 8649, 8464, 8281, 8100, 7921, 7744, 7569, 7396, 7225, 7056, 6889, 6724, 6561, | ||
47 | 6400, 6241, 6084, 5929, 5776, 5625, 5476, 5329, 5184, 5041, 4900, 4761, 4624, 4489, 4356, 4225, | ||
48 | 4096, 3969, 3844, 3721, 3600, 3481, 3364, 3249, 3136, 3025, 2916, 2809, 2704, 2601, 2500, 2401, | ||
49 | 2304, 2209, 2116, 2025, 1936, 1849, 1764, 1681, 1600, 1521, 1444, 1369, 1296, 1225, 1156, 1089, | ||
50 | 1024, 961, 900, 841, 784, 729, 676, 625, 576, 529, 484, 441, 400, 361, 324, 289, | ||
51 | 256, 225, 196, 169, 144, 121, 100, 81, 64, 49, 36, 25, 16, 9, 4, 1, | ||
52 | 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, | ||
53 | 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, | ||
54 | 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, | ||
55 | 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, | ||
56 | 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, | ||
57 | 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, | ||
58 | 9216, 9409, 9604, 9801, 10000, 10201, 10404, 10609, 10816, 11025, 11236, 11449, 11664, 11881, 12100, 12321, | ||
59 | 12544, 12769, 12996, 13225, 13456, 13689, 13924, 14161, 14400, 14641, 14884, 15129, 15376, 15625, 15876, 16129, | ||
60 | 16384, 16641, 16900, 17161, 17424, 17689, 17956, 18225, 18496, 18769, 19044, 19321, 19600, 19881, 20164, 20449, | ||
61 | 20736, 21025, 21316, 21609, 21904, 22201, 22500, 22801, 23104, 23409, 23716, 24025, 24336, 24649, 24964, 25281, | ||
62 | 25600, 25921, 26244, 26569, 26896, 27225, 27556, 27889, 28224, 28561, 28900, 29241, 29584, 29929, 30276, 30625, | ||
63 | 30976, 31329, 31684, 32041, 32400, 32761, 33124, 33489, 33856, 34225, 34596, 34969, 35344, 35721, 36100, 36481, | ||
64 | 36864, 37249, 37636, 38025, 38416, 38809, 39204, 39601, 40000, 40401, 40804, 41209, 41616, 42025, 42436, 42849, | ||
65 | 43264, 43681, 44100, 44521, 44944, 45369, 45796, 46225, 46656, 47089, 47524, 47961, 48400, 48841, 49284, 49729, | ||
66 | 50176, 50625, 51076, 51529, 51984, 52441, 52900, 53361, 53824, 54289, 54756, 55225, 55696, 56169, 56644, 57121, | ||
67 | 57600, 58081, 58564, 59049, 59536, 60025, 60516, 61009, 61504, 62001, 62500, 63001, 63504, 64009, 64516, 65025, | ||
68 | }; | ||
69 | |||
70 | 32 | static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
71 | ptrdiff_t stride, int h) | ||
72 | { | ||
73 | 32 | int s = 0, i; | |
74 | 32 | const uint32_t *sq = ff_square_tab + 256; | |
75 | |||
76 |
2/2✓ Branch 0 taken 256 times.
✓ Branch 1 taken 32 times.
|
288 | for (i = 0; i < h; i++) { |
77 | 256 | s += sq[pix1[0] - pix2[0]]; | |
78 | 256 | s += sq[pix1[1] - pix2[1]]; | |
79 | 256 | s += sq[pix1[2] - pix2[2]]; | |
80 | 256 | s += sq[pix1[3] - pix2[3]]; | |
81 | 256 | pix1 += stride; | |
82 | 256 | pix2 += stride; | |
83 | } | ||
84 | 32 | return s; | |
85 | } | ||
86 | |||
87 | 4814382 | static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
88 | ptrdiff_t stride, int h) | ||
89 | { | ||
90 | 4814382 | int s = 0, i; | |
91 | 4814382 | const uint32_t *sq = ff_square_tab + 256; | |
92 | |||
93 |
2/2✓ Branch 0 taken 38515056 times.
✓ Branch 1 taken 4814382 times.
|
43329438 | for (i = 0; i < h; i++) { |
94 | 38515056 | s += sq[pix1[0] - pix2[0]]; | |
95 | 38515056 | s += sq[pix1[1] - pix2[1]]; | |
96 | 38515056 | s += sq[pix1[2] - pix2[2]]; | |
97 | 38515056 | s += sq[pix1[3] - pix2[3]]; | |
98 | 38515056 | s += sq[pix1[4] - pix2[4]]; | |
99 | 38515056 | s += sq[pix1[5] - pix2[5]]; | |
100 | 38515056 | s += sq[pix1[6] - pix2[6]]; | |
101 | 38515056 | s += sq[pix1[7] - pix2[7]]; | |
102 | 38515056 | pix1 += stride; | |
103 | 38515056 | pix2 += stride; | |
104 | } | ||
105 | 4814382 | return s; | |
106 | } | ||
107 | |||
108 | 7187308 | static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
109 | ptrdiff_t stride, int h) | ||
110 | { | ||
111 | 7187308 | int s = 0, i; | |
112 | 7187308 | const uint32_t *sq = ff_square_tab + 256; | |
113 | |||
114 |
2/2✓ Branch 0 taken 114996544 times.
✓ Branch 1 taken 7187308 times.
|
122183852 | for (i = 0; i < h; i++) { |
115 | 114996544 | s += sq[pix1[0] - pix2[0]]; | |
116 | 114996544 | s += sq[pix1[1] - pix2[1]]; | |
117 | 114996544 | s += sq[pix1[2] - pix2[2]]; | |
118 | 114996544 | s += sq[pix1[3] - pix2[3]]; | |
119 | 114996544 | s += sq[pix1[4] - pix2[4]]; | |
120 | 114996544 | s += sq[pix1[5] - pix2[5]]; | |
121 | 114996544 | s += sq[pix1[6] - pix2[6]]; | |
122 | 114996544 | s += sq[pix1[7] - pix2[7]]; | |
123 | 114996544 | s += sq[pix1[8] - pix2[8]]; | |
124 | 114996544 | s += sq[pix1[9] - pix2[9]]; | |
125 | 114996544 | s += sq[pix1[10] - pix2[10]]; | |
126 | 114996544 | s += sq[pix1[11] - pix2[11]]; | |
127 | 114996544 | s += sq[pix1[12] - pix2[12]]; | |
128 | 114996544 | s += sq[pix1[13] - pix2[13]]; | |
129 | 114996544 | s += sq[pix1[14] - pix2[14]]; | |
130 | 114996544 | s += sq[pix1[15] - pix2[15]]; | |
131 | |||
132 | 114996544 | pix1 += stride; | |
133 | 114996544 | pix2 += stride; | |
134 | } | ||
135 | 7187308 | return s; | |
136 | } | ||
137 | |||
138 | ✗ | static int sum_abs_dctelem_c(int16_t *block) | |
139 | { | ||
140 | ✗ | int sum = 0, i; | |
141 | |||
142 | ✗ | for (i = 0; i < 64; i++) | |
143 | ✗ | sum += FFABS(block[i]); | |
144 | ✗ | return sum; | |
145 | } | ||
146 | |||
147 | #define avg2(a, b) (((a) + (b) + 1) >> 1) | ||
148 | #define avg4(a, b, c, d) (((a) + (b) + (c) + (d) + 2) >> 2) | ||
149 | |||
150 | 39613834 | static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
151 | ptrdiff_t stride, int h) | ||
152 | { | ||
153 | 39613834 | int s = 0, i; | |
154 | |||
155 |
2/2✓ Branch 0 taken 553274408 times.
✓ Branch 1 taken 39613834 times.
|
592888242 | for (i = 0; i < h; i++) { |
156 | 553274408 | s += abs(pix1[0] - pix2[0]); | |
157 | 553274408 | s += abs(pix1[1] - pix2[1]); | |
158 | 553274408 | s += abs(pix1[2] - pix2[2]); | |
159 | 553274408 | s += abs(pix1[3] - pix2[3]); | |
160 | 553274408 | s += abs(pix1[4] - pix2[4]); | |
161 | 553274408 | s += abs(pix1[5] - pix2[5]); | |
162 | 553274408 | s += abs(pix1[6] - pix2[6]); | |
163 | 553274408 | s += abs(pix1[7] - pix2[7]); | |
164 | 553274408 | s += abs(pix1[8] - pix2[8]); | |
165 | 553274408 | s += abs(pix1[9] - pix2[9]); | |
166 | 553274408 | s += abs(pix1[10] - pix2[10]); | |
167 | 553274408 | s += abs(pix1[11] - pix2[11]); | |
168 | 553274408 | s += abs(pix1[12] - pix2[12]); | |
169 | 553274408 | s += abs(pix1[13] - pix2[13]); | |
170 | 553274408 | s += abs(pix1[14] - pix2[14]); | |
171 | 553274408 | s += abs(pix1[15] - pix2[15]); | |
172 | 553274408 | pix1 += stride; | |
173 | 553274408 | pix2 += stride; | |
174 | } | ||
175 | 39613834 | return s; | |
176 | } | ||
177 | |||
178 | 32 | static inline int pix_median_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
179 | ptrdiff_t stride, int h) | ||
180 | { | ||
181 | 32 | int s = 0, i, j; | |
182 | |||
183 | #define V(x) (pix1[x] - pix2[x]) | ||
184 | |||
185 | 32 | s += abs(V(0)); | |
186 | 32 | s += abs(V(1) - V(0)); | |
187 | 32 | s += abs(V(2) - V(1)); | |
188 | 32 | s += abs(V(3) - V(2)); | |
189 | 32 | s += abs(V(4) - V(3)); | |
190 | 32 | s += abs(V(5) - V(4)); | |
191 | 32 | s += abs(V(6) - V(5)); | |
192 | 32 | s += abs(V(7) - V(6)); | |
193 | 32 | s += abs(V(8) - V(7)); | |
194 | 32 | s += abs(V(9) - V(8)); | |
195 | 32 | s += abs(V(10) - V(9)); | |
196 | 32 | s += abs(V(11) - V(10)); | |
197 | 32 | s += abs(V(12) - V(11)); | |
198 | 32 | s += abs(V(13) - V(12)); | |
199 | 32 | s += abs(V(14) - V(13)); | |
200 | 32 | s += abs(V(15) - V(14)); | |
201 | |||
202 | 32 | pix1 += stride; | |
203 | 32 | pix2 += stride; | |
204 | |||
205 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 32 times.
|
256 | for (i = 1; i < h; i++) { |
206 | 224 | s += abs(V(0) - V(-stride)); | |
207 |
2/2✓ Branch 0 taken 3360 times.
✓ Branch 1 taken 224 times.
|
3584 | for (j = 1; j < 16; j++) |
208 | 3360 | s += abs(V(j) - mid_pred(V(j-stride), V(j-1), V(j-stride) + V(j-1) - V(j-stride-1))); | |
209 | 224 | pix1 += stride; | |
210 | 224 | pix2 += stride; | |
211 | |||
212 | } | ||
213 | #undef V | ||
214 | 32 | return s; | |
215 | } | ||
216 | |||
217 | 3119040 | static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
218 | ptrdiff_t stride, int h) | ||
219 | { | ||
220 | 3119040 | int s = 0, i; | |
221 | |||
222 |
2/2✓ Branch 0 taken 40592712 times.
✓ Branch 1 taken 3119040 times.
|
43711752 | for (i = 0; i < h; i++) { |
223 | 40592712 | s += abs(pix1[0] - avg2(pix2[0], pix2[1])); | |
224 | 40592712 | s += abs(pix1[1] - avg2(pix2[1], pix2[2])); | |
225 | 40592712 | s += abs(pix1[2] - avg2(pix2[2], pix2[3])); | |
226 | 40592712 | s += abs(pix1[3] - avg2(pix2[3], pix2[4])); | |
227 | 40592712 | s += abs(pix1[4] - avg2(pix2[4], pix2[5])); | |
228 | 40592712 | s += abs(pix1[5] - avg2(pix2[5], pix2[6])); | |
229 | 40592712 | s += abs(pix1[6] - avg2(pix2[6], pix2[7])); | |
230 | 40592712 | s += abs(pix1[7] - avg2(pix2[7], pix2[8])); | |
231 | 40592712 | s += abs(pix1[8] - avg2(pix2[8], pix2[9])); | |
232 | 40592712 | s += abs(pix1[9] - avg2(pix2[9], pix2[10])); | |
233 | 40592712 | s += abs(pix1[10] - avg2(pix2[10], pix2[11])); | |
234 | 40592712 | s += abs(pix1[11] - avg2(pix2[11], pix2[12])); | |
235 | 40592712 | s += abs(pix1[12] - avg2(pix2[12], pix2[13])); | |
236 | 40592712 | s += abs(pix1[13] - avg2(pix2[13], pix2[14])); | |
237 | 40592712 | s += abs(pix1[14] - avg2(pix2[14], pix2[15])); | |
238 | 40592712 | s += abs(pix1[15] - avg2(pix2[15], pix2[16])); | |
239 | 40592712 | pix1 += stride; | |
240 | 40592712 | pix2 += stride; | |
241 | } | ||
242 | 3119040 | return s; | |
243 | } | ||
244 | |||
245 | 3119040 | static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
246 | ptrdiff_t stride, int h) | ||
247 | { | ||
248 | 3119040 | int s = 0, i; | |
249 | 3119040 | uint8_t *pix3 = pix2 + stride; | |
250 | |||
251 |
2/2✓ Branch 0 taken 40592712 times.
✓ Branch 1 taken 3119040 times.
|
43711752 | for (i = 0; i < h; i++) { |
252 | 40592712 | s += abs(pix1[0] - avg2(pix2[0], pix3[0])); | |
253 | 40592712 | s += abs(pix1[1] - avg2(pix2[1], pix3[1])); | |
254 | 40592712 | s += abs(pix1[2] - avg2(pix2[2], pix3[2])); | |
255 | 40592712 | s += abs(pix1[3] - avg2(pix2[3], pix3[3])); | |
256 | 40592712 | s += abs(pix1[4] - avg2(pix2[4], pix3[4])); | |
257 | 40592712 | s += abs(pix1[5] - avg2(pix2[5], pix3[5])); | |
258 | 40592712 | s += abs(pix1[6] - avg2(pix2[6], pix3[6])); | |
259 | 40592712 | s += abs(pix1[7] - avg2(pix2[7], pix3[7])); | |
260 | 40592712 | s += abs(pix1[8] - avg2(pix2[8], pix3[8])); | |
261 | 40592712 | s += abs(pix1[9] - avg2(pix2[9], pix3[9])); | |
262 | 40592712 | s += abs(pix1[10] - avg2(pix2[10], pix3[10])); | |
263 | 40592712 | s += abs(pix1[11] - avg2(pix2[11], pix3[11])); | |
264 | 40592712 | s += abs(pix1[12] - avg2(pix2[12], pix3[12])); | |
265 | 40592712 | s += abs(pix1[13] - avg2(pix2[13], pix3[13])); | |
266 | 40592712 | s += abs(pix1[14] - avg2(pix2[14], pix3[14])); | |
267 | 40592712 | s += abs(pix1[15] - avg2(pix2[15], pix3[15])); | |
268 | 40592712 | pix1 += stride; | |
269 | 40592712 | pix2 += stride; | |
270 | 40592712 | pix3 += stride; | |
271 | } | ||
272 | 3119040 | return s; | |
273 | } | ||
274 | |||
275 | 6238032 | static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
276 | ptrdiff_t stride, int h) | ||
277 | { | ||
278 | 6238032 | int s = 0, i; | |
279 | 6238032 | uint8_t *pix3 = pix2 + stride; | |
280 | |||
281 |
2/2✓ Branch 0 taken 81185040 times.
✓ Branch 1 taken 6238032 times.
|
87423072 | for (i = 0; i < h; i++) { |
282 | 81185040 | s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1])); | |
283 | 81185040 | s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2])); | |
284 | 81185040 | s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3])); | |
285 | 81185040 | s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4])); | |
286 | 81185040 | s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5])); | |
287 | 81185040 | s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6])); | |
288 | 81185040 | s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7])); | |
289 | 81185040 | s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8])); | |
290 | 81185040 | s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9])); | |
291 | 81185040 | s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10])); | |
292 | 81185040 | s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11])); | |
293 | 81185040 | s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12])); | |
294 | 81185040 | s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13])); | |
295 | 81185040 | s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14])); | |
296 | 81185040 | s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15])); | |
297 | 81185040 | s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16])); | |
298 | 81185040 | pix1 += stride; | |
299 | 81185040 | pix2 += stride; | |
300 | 81185040 | pix3 += stride; | |
301 | } | ||
302 | 6238032 | return s; | |
303 | } | ||
304 | |||
305 | 27725567 | static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
306 | ptrdiff_t stride, int h) | ||
307 | { | ||
308 | 27725567 | int s = 0, i; | |
309 | |||
310 |
2/2✓ Branch 0 taken 221804536 times.
✓ Branch 1 taken 27725567 times.
|
249530103 | for (i = 0; i < h; i++) { |
311 | 221804536 | s += abs(pix1[0] - pix2[0]); | |
312 | 221804536 | s += abs(pix1[1] - pix2[1]); | |
313 | 221804536 | s += abs(pix1[2] - pix2[2]); | |
314 | 221804536 | s += abs(pix1[3] - pix2[3]); | |
315 | 221804536 | s += abs(pix1[4] - pix2[4]); | |
316 | 221804536 | s += abs(pix1[5] - pix2[5]); | |
317 | 221804536 | s += abs(pix1[6] - pix2[6]); | |
318 | 221804536 | s += abs(pix1[7] - pix2[7]); | |
319 | 221804536 | pix1 += stride; | |
320 | 221804536 | pix2 += stride; | |
321 | } | ||
322 | 27725567 | return s; | |
323 | } | ||
324 | |||
325 | 32 | static inline int pix_median_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
326 | ptrdiff_t stride, int h) | ||
327 | { | ||
328 | 32 | int s = 0, i, j; | |
329 | |||
330 | #define V(x) (pix1[x] - pix2[x]) | ||
331 | |||
332 | 32 | s += abs(V(0)); | |
333 | 32 | s += abs(V(1) - V(0)); | |
334 | 32 | s += abs(V(2) - V(1)); | |
335 | 32 | s += abs(V(3) - V(2)); | |
336 | 32 | s += abs(V(4) - V(3)); | |
337 | 32 | s += abs(V(5) - V(4)); | |
338 | 32 | s += abs(V(6) - V(5)); | |
339 | 32 | s += abs(V(7) - V(6)); | |
340 | |||
341 | 32 | pix1 += stride; | |
342 | 32 | pix2 += stride; | |
343 | |||
344 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 32 times.
|
256 | for (i = 1; i < h; i++) { |
345 | 224 | s += abs(V(0) - V(-stride)); | |
346 |
2/2✓ Branch 0 taken 1568 times.
✓ Branch 1 taken 224 times.
|
1792 | for (j = 1; j < 8; j++) |
347 | 1568 | s += abs(V(j) - mid_pred(V(j-stride), V(j-1), V(j-stride) + V(j-1) - V(j-stride-1))); | |
348 | 224 | pix1 += stride; | |
349 | 224 | pix2 += stride; | |
350 | |||
351 | } | ||
352 | #undef V | ||
353 | 32 | return s; | |
354 | } | ||
355 | |||
356 | 837597 | static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
357 | ptrdiff_t stride, int h) | ||
358 | { | ||
359 | 837597 | int s = 0, i; | |
360 | |||
361 |
2/2✓ Branch 0 taken 6700776 times.
✓ Branch 1 taken 837597 times.
|
7538373 | for (i = 0; i < h; i++) { |
362 | 6700776 | s += abs(pix1[0] - avg2(pix2[0], pix2[1])); | |
363 | 6700776 | s += abs(pix1[1] - avg2(pix2[1], pix2[2])); | |
364 | 6700776 | s += abs(pix1[2] - avg2(pix2[2], pix2[3])); | |
365 | 6700776 | s += abs(pix1[3] - avg2(pix2[3], pix2[4])); | |
366 | 6700776 | s += abs(pix1[4] - avg2(pix2[4], pix2[5])); | |
367 | 6700776 | s += abs(pix1[5] - avg2(pix2[5], pix2[6])); | |
368 | 6700776 | s += abs(pix1[6] - avg2(pix2[6], pix2[7])); | |
369 | 6700776 | s += abs(pix1[7] - avg2(pix2[7], pix2[8])); | |
370 | 6700776 | pix1 += stride; | |
371 | 6700776 | pix2 += stride; | |
372 | } | ||
373 | 837597 | return s; | |
374 | } | ||
375 | |||
376 | 837597 | static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
377 | ptrdiff_t stride, int h) | ||
378 | { | ||
379 | 837597 | int s = 0, i; | |
380 | 837597 | uint8_t *pix3 = pix2 + stride; | |
381 | |||
382 |
2/2✓ Branch 0 taken 6700776 times.
✓ Branch 1 taken 837597 times.
|
7538373 | for (i = 0; i < h; i++) { |
383 | 6700776 | s += abs(pix1[0] - avg2(pix2[0], pix3[0])); | |
384 | 6700776 | s += abs(pix1[1] - avg2(pix2[1], pix3[1])); | |
385 | 6700776 | s += abs(pix1[2] - avg2(pix2[2], pix3[2])); | |
386 | 6700776 | s += abs(pix1[3] - avg2(pix2[3], pix3[3])); | |
387 | 6700776 | s += abs(pix1[4] - avg2(pix2[4], pix3[4])); | |
388 | 6700776 | s += abs(pix1[5] - avg2(pix2[5], pix3[5])); | |
389 | 6700776 | s += abs(pix1[6] - avg2(pix2[6], pix3[6])); | |
390 | 6700776 | s += abs(pix1[7] - avg2(pix2[7], pix3[7])); | |
391 | 6700776 | pix1 += stride; | |
392 | 6700776 | pix2 += stride; | |
393 | 6700776 | pix3 += stride; | |
394 | } | ||
395 | 837597 | return s; | |
396 | } | ||
397 | |||
398 | 1675146 | static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, | |
399 | ptrdiff_t stride, int h) | ||
400 | { | ||
401 | 1675146 | int s = 0, i; | |
402 | 1675146 | uint8_t *pix3 = pix2 + stride; | |
403 | |||
404 |
2/2✓ Branch 0 taken 13401168 times.
✓ Branch 1 taken 1675146 times.
|
15076314 | for (i = 0; i < h; i++) { |
405 | 13401168 | s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1])); | |
406 | 13401168 | s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2])); | |
407 | 13401168 | s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3])); | |
408 | 13401168 | s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4])); | |
409 | 13401168 | s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5])); | |
410 | 13401168 | s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6])); | |
411 | 13401168 | s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7])); | |
412 | 13401168 | s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8])); | |
413 | 13401168 | pix1 += stride; | |
414 | 13401168 | pix2 += stride; | |
415 | 13401168 | pix3 += stride; | |
416 | } | ||
417 | 1675146 | return s; | |
418 | } | ||
419 | |||
420 | 748189 | static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, | |
421 | ptrdiff_t stride, int h) | ||
422 | { | ||
423 | 748189 | int score1 = 0, score2 = 0, x, y; | |
424 | |||
425 |
2/2✓ Branch 0 taken 11970640 times.
✓ Branch 1 taken 748189 times.
|
12718829 | for (y = 0; y < h; y++) { |
426 |
2/2✓ Branch 0 taken 191530240 times.
✓ Branch 1 taken 11970640 times.
|
203500880 | for (x = 0; x < 16; x++) |
427 | 191530240 | score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]); | |
428 |
2/2✓ Branch 0 taken 11222451 times.
✓ Branch 1 taken 748189 times.
|
11970640 | if (y + 1 < h) { |
429 |
2/2✓ Branch 0 taken 168336765 times.
✓ Branch 1 taken 11222451 times.
|
179559216 | for (x = 0; x < 15; x++) |
430 | 168336765 | score2 += FFABS(s1[x] - s1[x + stride] - | |
431 | 168336765 | s1[x + 1] + s1[x + stride + 1]) - | |
432 | 168336765 | FFABS(s2[x] - s2[x + stride] - | |
433 | s2[x + 1] + s2[x + stride + 1]); | ||
434 | } | ||
435 | 11970640 | s1 += stride; | |
436 | 11970640 | s2 += stride; | |
437 | } | ||
438 | |||
439 |
2/2✓ Branch 0 taken 748141 times.
✓ Branch 1 taken 48 times.
|
748189 | if (c) |
440 | 748141 | return score1 + FFABS(score2) * c->avctx->nsse_weight; | |
441 | else | ||
442 | 48 | return score1 + FFABS(score2) * 8; | |
443 | } | ||
444 | |||
445 | 48 | static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, | |
446 | ptrdiff_t stride, int h) | ||
447 | { | ||
448 | 48 | int score1 = 0, score2 = 0, x, y; | |
449 | |||
450 |
2/2✓ Branch 0 taken 384 times.
✓ Branch 1 taken 48 times.
|
432 | for (y = 0; y < h; y++) { |
451 |
2/2✓ Branch 0 taken 3072 times.
✓ Branch 1 taken 384 times.
|
3456 | for (x = 0; x < 8; x++) |
452 | 3072 | score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]); | |
453 |
2/2✓ Branch 0 taken 336 times.
✓ Branch 1 taken 48 times.
|
384 | if (y + 1 < h) { |
454 |
2/2✓ Branch 0 taken 2352 times.
✓ Branch 1 taken 336 times.
|
2688 | for (x = 0; x < 7; x++) |
455 | 2352 | score2 += FFABS(s1[x] - s1[x + stride] - | |
456 | 2352 | s1[x + 1] + s1[x + stride + 1]) - | |
457 | 2352 | FFABS(s2[x] - s2[x + stride] - | |
458 | s2[x + 1] + s2[x + stride + 1]); | ||
459 | } | ||
460 | 384 | s1 += stride; | |
461 | 384 | s2 += stride; | |
462 | } | ||
463 | |||
464 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
|
48 | if (c) |
465 | ✗ | return score1 + FFABS(score2) * c->avctx->nsse_weight; | |
466 | else | ||
467 | 48 | return score1 + FFABS(score2) * 8; | |
468 | } | ||
469 | |||
470 | ✗ | static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b, | |
471 | ptrdiff_t stride, int h) | ||
472 | { | ||
473 | ✗ | return 0; | |
474 | } | ||
475 | |||
476 | 38950 | void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type) | |
477 | { | ||
478 | int i; | ||
479 | |||
480 | 38950 | memset(cmp, 0, sizeof(void *) * 6); | |
481 | |||
482 |
2/2✓ Branch 0 taken 233700 times.
✓ Branch 1 taken 38950 times.
|
272650 | for (i = 0; i < 6; i++) { |
483 |
7/17✓ Branch 0 taken 213612 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 7200 times.
✓ Branch 3 taken 2400 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 1098 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 1254 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✓ Branch 13 taken 4824 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 3312 times.
✗ Branch 16 not taken.
|
233700 | switch (type & 0xFF) { |
484 | 213612 | case FF_CMP_SAD: | |
485 | 213612 | cmp[i] = c->sad[i]; | |
486 | 213612 | break; | |
487 | ✗ | case FF_CMP_MEDIAN_SAD: | |
488 | ✗ | cmp[i] = c->median_sad[i]; | |
489 | ✗ | break; | |
490 | 7200 | case FF_CMP_SATD: | |
491 | 7200 | cmp[i] = c->hadamard8_diff[i]; | |
492 | 7200 | break; | |
493 | 2400 | case FF_CMP_SSE: | |
494 | 2400 | cmp[i] = c->sse[i]; | |
495 | 2400 | break; | |
496 | ✗ | case FF_CMP_DCT: | |
497 | ✗ | cmp[i] = c->dct_sad[i]; | |
498 | ✗ | break; | |
499 | ✗ | case FF_CMP_DCT264: | |
500 | ✗ | cmp[i] = c->dct264_sad[i]; | |
501 | ✗ | break; | |
502 | 1098 | case FF_CMP_DCTMAX: | |
503 | 1098 | cmp[i] = c->dct_max[i]; | |
504 | 1098 | break; | |
505 | ✗ | case FF_CMP_PSNR: | |
506 | ✗ | cmp[i] = c->quant_psnr[i]; | |
507 | ✗ | break; | |
508 | ✗ | case FF_CMP_BIT: | |
509 | ✗ | cmp[i] = c->bit[i]; | |
510 | ✗ | break; | |
511 | ✗ | case FF_CMP_RD: | |
512 | ✗ | cmp[i] = c->rd[i]; | |
513 | ✗ | break; | |
514 | 1254 | case FF_CMP_VSAD: | |
515 | 1254 | cmp[i] = c->vsad[i]; | |
516 | 1254 | break; | |
517 | ✗ | case FF_CMP_VSSE: | |
518 | ✗ | cmp[i] = c->vsse[i]; | |
519 | ✗ | break; | |
520 | ✗ | case FF_CMP_ZERO: | |
521 | ✗ | cmp[i] = zero_cmp; | |
522 | ✗ | break; | |
523 | 4824 | case FF_CMP_NSSE: | |
524 | 4824 | cmp[i] = c->nsse[i]; | |
525 | 4824 | break; | |
526 | #if CONFIG_DWT | ||
527 | ✗ | case FF_CMP_W53: | |
528 | ✗ | cmp[i]= c->w53[i]; | |
529 | ✗ | break; | |
530 | 3312 | case FF_CMP_W97: | |
531 | 3312 | cmp[i]= c->w97[i]; | |
532 | 3312 | break; | |
533 | #endif | ||
534 | ✗ | default: | |
535 | ✗ | av_log(NULL, AV_LOG_ERROR, | |
536 | "internal error in cmp function selection\n"); | ||
537 | } | ||
538 | } | ||
539 | 38950 | } | |
540 | |||
541 | #define BUTTERFLY2(o1, o2, i1, i2) \ | ||
542 | o1 = (i1) + (i2); \ | ||
543 | o2 = (i1) - (i2); | ||
544 | |||
545 | #define BUTTERFLY1(x, y) \ | ||
546 | { \ | ||
547 | int a, b; \ | ||
548 | a = x; \ | ||
549 | b = y; \ | ||
550 | x = a + b; \ | ||
551 | y = a - b; \ | ||
552 | } | ||
553 | |||
554 | #define BUTTERFLYA(x, y) (FFABS((x) + (y)) + FFABS((x) - (y))) | ||
555 | |||
556 | 15481940 | static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst, | |
557 | uint8_t *src, ptrdiff_t stride, int h) | ||
558 | { | ||
559 | 15481940 | int i, temp[64], sum = 0; | |
560 | |||
561 | av_assert2(h == 8); | ||
562 | |||
563 |
2/2✓ Branch 0 taken 123855520 times.
✓ Branch 1 taken 15481940 times.
|
139337460 | for (i = 0; i < 8; i++) { |
564 | // FIXME: try pointer walks | ||
565 | 123855520 | BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1], | |
566 | src[stride * i + 0] - dst[stride * i + 0], | ||
567 | src[stride * i + 1] - dst[stride * i + 1]); | ||
568 | 123855520 | BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3], | |
569 | src[stride * i + 2] - dst[stride * i + 2], | ||
570 | src[stride * i + 3] - dst[stride * i + 3]); | ||
571 | 123855520 | BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5], | |
572 | src[stride * i + 4] - dst[stride * i + 4], | ||
573 | src[stride * i + 5] - dst[stride * i + 5]); | ||
574 | 123855520 | BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7], | |
575 | src[stride * i + 6] - dst[stride * i + 6], | ||
576 | src[stride * i + 7] - dst[stride * i + 7]); | ||
577 | |||
578 | 123855520 | BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]); | |
579 | 123855520 | BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]); | |
580 | 123855520 | BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]); | |
581 | 123855520 | BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]); | |
582 | |||
583 | 123855520 | BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]); | |
584 | 123855520 | BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]); | |
585 | 123855520 | BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]); | |
586 | 123855520 | BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]); | |
587 | } | ||
588 | |||
589 |
2/2✓ Branch 0 taken 123855520 times.
✓ Branch 1 taken 15481940 times.
|
139337460 | for (i = 0; i < 8; i++) { |
590 | 123855520 | BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]); | |
591 | 123855520 | BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]); | |
592 | 123855520 | BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]); | |
593 | 123855520 | BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]); | |
594 | |||
595 | 123855520 | BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]); | |
596 | 123855520 | BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]); | |
597 | 123855520 | BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]); | |
598 | 123855520 | BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]); | |
599 | |||
600 | 123855520 | sum += BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i]) + | |
601 | 123855520 | BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i]) + | |
602 | 123855520 | BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i]) + | |
603 | 123855520 | BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]); | |
604 | } | ||
605 | 15481940 | return sum; | |
606 | } | ||
607 | |||
608 | 96 | static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src, | |
609 | uint8_t *dummy, ptrdiff_t stride, int h) | ||
610 | { | ||
611 | 96 | int i, temp[64], sum = 0; | |
612 | |||
613 | av_assert2(h == 8); | ||
614 | |||
615 |
2/2✓ Branch 0 taken 768 times.
✓ Branch 1 taken 96 times.
|
864 | for (i = 0; i < 8; i++) { |
616 | // FIXME: try pointer walks | ||
617 | 768 | BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1], | |
618 | src[stride * i + 0], src[stride * i + 1]); | ||
619 | 768 | BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3], | |
620 | src[stride * i + 2], src[stride * i + 3]); | ||
621 | 768 | BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5], | |
622 | src[stride * i + 4], src[stride * i + 5]); | ||
623 | 768 | BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7], | |
624 | src[stride * i + 6], src[stride * i + 7]); | ||
625 | |||
626 | 768 | BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]); | |
627 | 768 | BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]); | |
628 | 768 | BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]); | |
629 | 768 | BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]); | |
630 | |||
631 | 768 | BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]); | |
632 | 768 | BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]); | |
633 | 768 | BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]); | |
634 | 768 | BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]); | |
635 | } | ||
636 | |||
637 |
2/2✓ Branch 0 taken 768 times.
✓ Branch 1 taken 96 times.
|
864 | for (i = 0; i < 8; i++) { |
638 | 768 | BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]); | |
639 | 768 | BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]); | |
640 | 768 | BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]); | |
641 | 768 | BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]); | |
642 | |||
643 | 768 | BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]); | |
644 | 768 | BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]); | |
645 | 768 | BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]); | |
646 | 768 | BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]); | |
647 | |||
648 | 768 | sum += | |
649 | 768 | BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i]) | |
650 | 768 | + BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i]) | |
651 | 768 | + BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i]) | |
652 | 768 | + BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]); | |
653 | } | ||
654 | |||
655 | 96 | sum -= FFABS(temp[8 * 0] + temp[8 * 4]); // -mean | |
656 | |||
657 | 96 | return sum; | |
658 | } | ||
659 | |||
660 | ✗ | static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1, | |
661 | uint8_t *src2, ptrdiff_t stride, int h) | ||
662 | { | ||
663 | ✗ | LOCAL_ALIGNED_16(int16_t, temp, [64]); | |
664 | |||
665 | av_assert2(h == 8); | ||
666 | |||
667 | ✗ | s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride); | |
668 | ✗ | s->fdsp.fdct(temp); | |
669 | ✗ | return s->mecc.sum_abs_dctelem(temp); | |
670 | } | ||
671 | |||
672 | #if CONFIG_GPL | ||
673 | #define DCT8_1D \ | ||
674 | { \ | ||
675 | const int s07 = SRC(0) + SRC(7); \ | ||
676 | const int s16 = SRC(1) + SRC(6); \ | ||
677 | const int s25 = SRC(2) + SRC(5); \ | ||
678 | const int s34 = SRC(3) + SRC(4); \ | ||
679 | const int a0 = s07 + s34; \ | ||
680 | const int a1 = s16 + s25; \ | ||
681 | const int a2 = s07 - s34; \ | ||
682 | const int a3 = s16 - s25; \ | ||
683 | const int d07 = SRC(0) - SRC(7); \ | ||
684 | const int d16 = SRC(1) - SRC(6); \ | ||
685 | const int d25 = SRC(2) - SRC(5); \ | ||
686 | const int d34 = SRC(3) - SRC(4); \ | ||
687 | const int a4 = d16 + d25 + (d07 + (d07 >> 1)); \ | ||
688 | const int a5 = d07 - d34 - (d25 + (d25 >> 1)); \ | ||
689 | const int a6 = d07 + d34 - (d16 + (d16 >> 1)); \ | ||
690 | const int a7 = d16 - d25 + (d34 + (d34 >> 1)); \ | ||
691 | DST(0, a0 + a1); \ | ||
692 | DST(1, a4 + (a7 >> 2)); \ | ||
693 | DST(2, a2 + (a3 >> 1)); \ | ||
694 | DST(3, a5 + (a6 >> 2)); \ | ||
695 | DST(4, a0 - a1); \ | ||
696 | DST(5, a6 - (a5 >> 2)); \ | ||
697 | DST(6, (a2 >> 1) - a3); \ | ||
698 | DST(7, (a4 >> 2) - a7); \ | ||
699 | } | ||
700 | |||
701 | ✗ | static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1, | |
702 | uint8_t *src2, ptrdiff_t stride, int h) | ||
703 | { | ||
704 | int16_t dct[8][8]; | ||
705 | ✗ | int i, sum = 0; | |
706 | |||
707 | ✗ | s->pdsp.diff_pixels_unaligned(dct[0], src1, src2, stride); | |
708 | |||
709 | #define SRC(x) dct[i][x] | ||
710 | #define DST(x, v) dct[i][x] = v | ||
711 | ✗ | for (i = 0; i < 8; i++) | |
712 | ✗ | DCT8_1D | |
713 | #undef SRC | ||
714 | #undef DST | ||
715 | |||
716 | #define SRC(x) dct[x][i] | ||
717 | #define DST(x, v) sum += FFABS(v) | ||
718 | ✗ | for (i = 0; i < 8; i++) | |
719 | ✗ | DCT8_1D | |
720 | #undef SRC | ||
721 | #undef DST | ||
722 | ✗ | return sum; | |
723 | } | ||
724 | #endif | ||
725 | |||
726 | ✗ | static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1, | |
727 | uint8_t *src2, ptrdiff_t stride, int h) | ||
728 | { | ||
729 | ✗ | LOCAL_ALIGNED_16(int16_t, temp, [64]); | |
730 | ✗ | int sum = 0, i; | |
731 | |||
732 | av_assert2(h == 8); | ||
733 | |||
734 | ✗ | s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride); | |
735 | ✗ | s->fdsp.fdct(temp); | |
736 | |||
737 | ✗ | for (i = 0; i < 64; i++) | |
738 | ✗ | sum = FFMAX(sum, FFABS(temp[i])); | |
739 | |||
740 | ✗ | return sum; | |
741 | } | ||
742 | |||
743 | ✗ | static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1, | |
744 | uint8_t *src2, ptrdiff_t stride, int h) | ||
745 | { | ||
746 | ✗ | LOCAL_ALIGNED_16(int16_t, temp, [64 * 2]); | |
747 | ✗ | int16_t *const bak = temp + 64; | |
748 | ✗ | int sum = 0, i; | |
749 | |||
750 | av_assert2(h == 8); | ||
751 | ✗ | s->mb_intra = 0; | |
752 | |||
753 | ✗ | s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride); | |
754 | |||
755 | ✗ | memcpy(bak, temp, 64 * sizeof(int16_t)); | |
756 | |||
757 | ✗ | s->block_last_index[0 /* FIXME */] = | |
758 | ✗ | s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i); | |
759 | ✗ | s->dct_unquantize_inter(s, temp, 0, s->qscale); | |
760 | ✗ | ff_simple_idct_int16_8bit(temp); // FIXME | |
761 | |||
762 | ✗ | for (i = 0; i < 64; i++) | |
763 | ✗ | sum += (temp[i] - bak[i]) * (temp[i] - bak[i]); | |
764 | |||
765 | ✗ | return sum; | |
766 | } | ||
767 | |||
768 | ✗ | static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, | |
769 | ptrdiff_t stride, int h) | ||
770 | { | ||
771 | ✗ | const uint8_t *scantable = s->intra_scantable.permutated; | |
772 | ✗ | LOCAL_ALIGNED_16(int16_t, temp, [64]); | |
773 | ✗ | LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]); | |
774 | ✗ | LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]); | |
775 | int i, last, run, bits, level, distortion, start_i; | ||
776 | ✗ | const int esc_length = s->ac_esc_length; | |
777 | uint8_t *length, *last_length; | ||
778 | |||
779 | av_assert2(h == 8); | ||
780 | |||
781 | ✗ | copy_block8(lsrc1, src1, 8, stride, 8); | |
782 | ✗ | copy_block8(lsrc2, src2, 8, stride, 8); | |
783 | |||
784 | ✗ | s->pdsp.diff_pixels(temp, lsrc1, lsrc2, 8); | |
785 | |||
786 | ✗ | s->block_last_index[0 /* FIXME */] = | |
787 | last = | ||
788 | ✗ | s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i); | |
789 | |||
790 | ✗ | bits = 0; | |
791 | |||
792 | ✗ | if (s->mb_intra) { | |
793 | ✗ | start_i = 1; | |
794 | ✗ | length = s->intra_ac_vlc_length; | |
795 | ✗ | last_length = s->intra_ac_vlc_last_length; | |
796 | ✗ | bits += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma | |
797 | } else { | ||
798 | ✗ | start_i = 0; | |
799 | ✗ | length = s->inter_ac_vlc_length; | |
800 | ✗ | last_length = s->inter_ac_vlc_last_length; | |
801 | } | ||
802 | |||
803 | ✗ | if (last >= start_i) { | |
804 | ✗ | run = 0; | |
805 | ✗ | for (i = start_i; i < last; i++) { | |
806 | ✗ | int j = scantable[i]; | |
807 | ✗ | level = temp[j]; | |
808 | |||
809 | ✗ | if (level) { | |
810 | ✗ | level += 64; | |
811 | ✗ | if ((level & (~127)) == 0) | |
812 | ✗ | bits += length[UNI_AC_ENC_INDEX(run, level)]; | |
813 | else | ||
814 | ✗ | bits += esc_length; | |
815 | ✗ | run = 0; | |
816 | } else | ||
817 | ✗ | run++; | |
818 | } | ||
819 | ✗ | i = scantable[last]; | |
820 | |||
821 | ✗ | level = temp[i] + 64; | |
822 | |||
823 | av_assert2(level - 64); | ||
824 | |||
825 | ✗ | if ((level & (~127)) == 0) { | |
826 | ✗ | bits += last_length[UNI_AC_ENC_INDEX(run, level)]; | |
827 | } else | ||
828 | ✗ | bits += esc_length; | |
829 | } | ||
830 | |||
831 | ✗ | if (last >= 0) { | |
832 | ✗ | if (s->mb_intra) | |
833 | ✗ | s->dct_unquantize_intra(s, temp, 0, s->qscale); | |
834 | else | ||
835 | ✗ | s->dct_unquantize_inter(s, temp, 0, s->qscale); | |
836 | } | ||
837 | |||
838 | ✗ | s->idsp.idct_add(lsrc2, 8, temp); | |
839 | |||
840 | ✗ | distortion = s->mecc.sse[1](NULL, lsrc2, lsrc1, 8, 8); | |
841 | |||
842 | ✗ | return distortion + ((bits * s->qscale * s->qscale * 109 + 64) >> 7); | |
843 | } | ||
844 | |||
845 | ✗ | static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, | |
846 | ptrdiff_t stride, int h) | ||
847 | { | ||
848 | ✗ | const uint8_t *scantable = s->intra_scantable.permutated; | |
849 | ✗ | LOCAL_ALIGNED_16(int16_t, temp, [64]); | |
850 | int i, last, run, bits, level, start_i; | ||
851 | ✗ | const int esc_length = s->ac_esc_length; | |
852 | uint8_t *length, *last_length; | ||
853 | |||
854 | av_assert2(h == 8); | ||
855 | |||
856 | ✗ | s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride); | |
857 | |||
858 | ✗ | s->block_last_index[0 /* FIXME */] = | |
859 | last = | ||
860 | ✗ | s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i); | |
861 | |||
862 | ✗ | bits = 0; | |
863 | |||
864 | ✗ | if (s->mb_intra) { | |
865 | ✗ | start_i = 1; | |
866 | ✗ | length = s->intra_ac_vlc_length; | |
867 | ✗ | last_length = s->intra_ac_vlc_last_length; | |
868 | ✗ | bits += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma | |
869 | } else { | ||
870 | ✗ | start_i = 0; | |
871 | ✗ | length = s->inter_ac_vlc_length; | |
872 | ✗ | last_length = s->inter_ac_vlc_last_length; | |
873 | } | ||
874 | |||
875 | ✗ | if (last >= start_i) { | |
876 | ✗ | run = 0; | |
877 | ✗ | for (i = start_i; i < last; i++) { | |
878 | ✗ | int j = scantable[i]; | |
879 | ✗ | level = temp[j]; | |
880 | |||
881 | ✗ | if (level) { | |
882 | ✗ | level += 64; | |
883 | ✗ | if ((level & (~127)) == 0) | |
884 | ✗ | bits += length[UNI_AC_ENC_INDEX(run, level)]; | |
885 | else | ||
886 | ✗ | bits += esc_length; | |
887 | ✗ | run = 0; | |
888 | } else | ||
889 | ✗ | run++; | |
890 | } | ||
891 | ✗ | i = scantable[last]; | |
892 | |||
893 | ✗ | level = temp[i] + 64; | |
894 | |||
895 | av_assert2(level - 64); | ||
896 | |||
897 | ✗ | if ((level & (~127)) == 0) | |
898 | ✗ | bits += last_length[UNI_AC_ENC_INDEX(run, level)]; | |
899 | else | ||
900 | ✗ | bits += esc_length; | |
901 | } | ||
902 | |||
903 | ✗ | return bits; | |
904 | } | ||
905 | |||
906 | #define VSAD_INTRA(size) \ | ||
907 | static int vsad_intra ## size ## _c(MpegEncContext *c, \ | ||
908 | uint8_t *s, uint8_t *dummy, \ | ||
909 | ptrdiff_t stride, int h) \ | ||
910 | { \ | ||
911 | int score = 0, x, y; \ | ||
912 | \ | ||
913 | for (y = 1; y < h; y++) { \ | ||
914 | for (x = 0; x < size; x += 4) { \ | ||
915 | score += FFABS(s[x] - s[x + stride]) + \ | ||
916 | FFABS(s[x + 1] - s[x + stride + 1]) + \ | ||
917 | FFABS(s[x + 2] - s[x + 2 + stride]) + \ | ||
918 | FFABS(s[x + 3] - s[x + 3 + stride]); \ | ||
919 | } \ | ||
920 | s += stride; \ | ||
921 | } \ | ||
922 | \ | ||
923 | return score; \ | ||
924 | } | ||
925 |
4/4✓ Branch 0 taken 672 times.
✓ Branch 1 taken 336 times.
✓ Branch 2 taken 336 times.
✓ Branch 3 taken 48 times.
|
1056 | VSAD_INTRA(8) |
926 |
4/4✓ Branch 0 taken 34481776 times.
✓ Branch 1 taken 8620444 times.
✓ Branch 2 taken 8620444 times.
✓ Branch 3 taken 1231492 times.
|
44333712 | VSAD_INTRA(16) |
927 | |||
928 | #define VSAD(size) \ | ||
929 | static int vsad ## size ## _c(MpegEncContext *c, \ | ||
930 | uint8_t *s1, uint8_t *s2, \ | ||
931 | ptrdiff_t stride, int h) \ | ||
932 | { \ | ||
933 | int score = 0, x, y; \ | ||
934 | \ | ||
935 | for (y = 1; y < h; y++) { \ | ||
936 | for (x = 0; x < size; x++) \ | ||
937 | score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]); \ | ||
938 | s1 += stride; \ | ||
939 | s2 += stride; \ | ||
940 | } \ | ||
941 | \ | ||
942 | return score; \ | ||
943 | } | ||
944 |
4/4✓ Branch 0 taken 1792 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 32 times.
|
2048 | VSAD(8) |
945 |
4/4✓ Branch 0 taken 214486048 times.
✓ Branch 1 taken 13405378 times.
✓ Branch 2 taken 13405378 times.
✓ Branch 3 taken 1915054 times.
|
229806480 | VSAD(16) |
946 | |||
947 | #define SQ(a) ((a) * (a)) | ||
948 | #define VSSE_INTRA(size) \ | ||
949 | static int vsse_intra ## size ## _c(MpegEncContext *c, \ | ||
950 | uint8_t *s, uint8_t *dummy, \ | ||
951 | ptrdiff_t stride, int h) \ | ||
952 | { \ | ||
953 | int score = 0, x, y; \ | ||
954 | \ | ||
955 | for (y = 1; y < h; y++) { \ | ||
956 | for (x = 0; x < size; x += 4) { \ | ||
957 | score += SQ(s[x] - s[x + stride]) + \ | ||
958 | SQ(s[x + 1] - s[x + stride + 1]) + \ | ||
959 | SQ(s[x + 2] - s[x + stride + 2]) + \ | ||
960 | SQ(s[x + 3] - s[x + stride + 3]); \ | ||
961 | } \ | ||
962 | s += stride; \ | ||
963 | } \ | ||
964 | \ | ||
965 | return score; \ | ||
966 | } | ||
967 |
4/4✓ Branch 0 taken 448 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 32 times.
|
704 | VSSE_INTRA(8) |
968 |
4/4✓ Branch 0 taken 896 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 32 times.
|
1152 | VSSE_INTRA(16) |
969 | |||
970 | #define VSSE(size) \ | ||
971 | static int vsse ## size ## _c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, \ | ||
972 | ptrdiff_t stride, int h) \ | ||
973 | { \ | ||
974 | int score = 0, x, y; \ | ||
975 | \ | ||
976 | for (y = 1; y < h; y++) { \ | ||
977 | for (x = 0; x < size; x++) \ | ||
978 | score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]); \ | ||
979 | s1 += stride; \ | ||
980 | s2 += stride; \ | ||
981 | } \ | ||
982 | \ | ||
983 | return score; \ | ||
984 | } | ||
985 |
4/4✓ Branch 0 taken 1792 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 32 times.
|
2048 | VSSE(8) |
986 |
4/4✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 224 times.
✓ Branch 2 taken 224 times.
✓ Branch 3 taken 32 times.
|
3840 | VSSE(16) |
987 | |||
988 | #define WRAPPER8_16_SQ(name8, name16) \ | ||
989 | static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src, \ | ||
990 | ptrdiff_t stride, int h) \ | ||
991 | { \ | ||
992 | int score = 0; \ | ||
993 | \ | ||
994 | score += name8(s, dst, src, stride, 8); \ | ||
995 | score += name8(s, dst + 8, src + 8, stride, 8); \ | ||
996 | if (h == 16) { \ | ||
997 | dst += 8 * stride; \ | ||
998 | src += 8 * stride; \ | ||
999 | score += name8(s, dst, src, stride, 8); \ | ||
1000 | score += name8(s, dst + 8, src + 8, stride, 8); \ | ||
1001 | } \ | ||
1002 | return score; \ | ||
1003 | } | ||
1004 | |||
1005 |
2/2✓ Branch 2 taken 3613091 times.
✓ Branch 3 taken 48 times.
|
3613139 | WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c) |
1006 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 32 times.
|
32 | WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c) |
1007 | ✗ | WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c) | |
1008 | #if CONFIG_GPL | ||
1009 | ✗ | WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c) | |
1010 | #endif | ||
1011 | ✗ | WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c) | |
1012 | ✗ | WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c) | |
1013 | ✗ | WRAPPER8_16_SQ(rd8x8_c, rd16_c) | |
1014 | ✗ | WRAPPER8_16_SQ(bit8x8_c, bit16_c) | |
1015 | |||
1016 | 1015 | av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx) | |
1017 | { | ||
1018 | 1015 | c->sum_abs_dctelem = sum_abs_dctelem_c; | |
1019 | |||
1020 | /* TODO [0] 16 [1] 8 */ | ||
1021 | 1015 | c->pix_abs[0][0] = pix_abs16_c; | |
1022 | 1015 | c->pix_abs[0][1] = pix_abs16_x2_c; | |
1023 | 1015 | c->pix_abs[0][2] = pix_abs16_y2_c; | |
1024 | 1015 | c->pix_abs[0][3] = pix_abs16_xy2_c; | |
1025 | 1015 | c->pix_abs[1][0] = pix_abs8_c; | |
1026 | 1015 | c->pix_abs[1][1] = pix_abs8_x2_c; | |
1027 | 1015 | c->pix_abs[1][2] = pix_abs8_y2_c; | |
1028 | 1015 | c->pix_abs[1][3] = pix_abs8_xy2_c; | |
1029 | |||
1030 | #define SET_CMP_FUNC(name) \ | ||
1031 | c->name[0] = name ## 16_c; \ | ||
1032 | c->name[1] = name ## 8x8_c; | ||
1033 | |||
1034 | 1015 | SET_CMP_FUNC(hadamard8_diff) | |
1035 | 1015 | c->hadamard8_diff[4] = hadamard8_intra16_c; | |
1036 | 1015 | c->hadamard8_diff[5] = hadamard8_intra8x8_c; | |
1037 | 1015 | SET_CMP_FUNC(dct_sad) | |
1038 | 1015 | SET_CMP_FUNC(dct_max) | |
1039 | #if CONFIG_GPL | ||
1040 | 1015 | SET_CMP_FUNC(dct264_sad) | |
1041 | #endif | ||
1042 | 1015 | c->sad[0] = pix_abs16_c; | |
1043 | 1015 | c->sad[1] = pix_abs8_c; | |
1044 | 1015 | c->sse[0] = sse16_c; | |
1045 | 1015 | c->sse[1] = sse8_c; | |
1046 | 1015 | c->sse[2] = sse4_c; | |
1047 | 1015 | SET_CMP_FUNC(quant_psnr) | |
1048 | 1015 | SET_CMP_FUNC(rd) | |
1049 | 1015 | SET_CMP_FUNC(bit) | |
1050 | 1015 | c->vsad[0] = vsad16_c; | |
1051 | 1015 | c->vsad[1] = vsad8_c; | |
1052 | 1015 | c->vsad[4] = vsad_intra16_c; | |
1053 | 1015 | c->vsad[5] = vsad_intra8_c; | |
1054 | 1015 | c->vsse[0] = vsse16_c; | |
1055 | 1015 | c->vsse[1] = vsse8_c; | |
1056 | 1015 | c->vsse[4] = vsse_intra16_c; | |
1057 | 1015 | c->vsse[5] = vsse_intra8_c; | |
1058 | 1015 | c->nsse[0] = nsse16_c; | |
1059 | 1015 | c->nsse[1] = nsse8_c; | |
1060 | #if CONFIG_SNOW_DECODER || CONFIG_SNOW_ENCODER | ||
1061 | 1015 | ff_dsputil_init_dwt(c); | |
1062 | #endif | ||
1063 | |||
1064 | #if ARCH_AARCH64 | ||
1065 | ff_me_cmp_init_aarch64(c, avctx); | ||
1066 | #elif ARCH_ALPHA | ||
1067 | ff_me_cmp_init_alpha(c, avctx); | ||
1068 | #elif ARCH_ARM | ||
1069 | ff_me_cmp_init_arm(c, avctx); | ||
1070 | #elif ARCH_PPC | ||
1071 | ff_me_cmp_init_ppc(c, avctx); | ||
1072 | #elif ARCH_X86 | ||
1073 | 1015 | ff_me_cmp_init_x86(c, avctx); | |
1074 | #elif ARCH_MIPS | ||
1075 | ff_me_cmp_init_mips(c, avctx); | ||
1076 | #endif | ||
1077 | |||
1078 | 1015 | c->median_sad[0] = pix_median_abs16_c; | |
1079 | 1015 | c->median_sad[1] = pix_median_abs8_c; | |
1080 | 1015 | } | |
1081 |