Line data Source code
1 : /*
2 : * Copyright (c) 2014 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 <assert.h>
12 : #include <limits.h>
13 : #include <math.h>
14 : #include <stdio.h>
15 : #include <stdlib.h>
16 : #include <string.h>
17 :
18 : #include "./vpx_config.h"
19 : #if CONFIG_VP9_HIGHBITDEPTH
20 : #include "vpx_dsp/vpx_dsp_common.h"
21 : #endif // CONFIG_VP9_HIGHBITDEPTH
22 : #include "vpx_ports/mem.h"
23 : #include "vp9/common/vp9_common.h"
24 : #include "vp9/encoder/vp9_resize.h"
25 :
26 : #define FILTER_BITS 7
27 :
28 : #define INTERP_TAPS 8
29 : #define SUBPEL_BITS 5
30 : #define SUBPEL_MASK ((1 << SUBPEL_BITS) - 1)
31 : #define INTERP_PRECISION_BITS 32
32 :
33 : typedef int16_t interp_kernel[INTERP_TAPS];
34 :
35 : // Filters for interpolation (0.5-band) - note this also filters integer pels.
36 : static const interp_kernel filteredinterp_filters500[(1 << SUBPEL_BITS)] = {
37 : { -3, 0, 35, 64, 35, 0, -3, 0 }, { -3, -1, 34, 64, 36, 1, -3, 0 },
38 : { -3, -1, 32, 64, 38, 1, -3, 0 }, { -2, -2, 31, 63, 39, 2, -3, 0 },
39 : { -2, -2, 29, 63, 41, 2, -3, 0 }, { -2, -2, 28, 63, 42, 3, -4, 0 },
40 : { -2, -3, 27, 63, 43, 4, -4, 0 }, { -2, -3, 25, 62, 45, 5, -4, 0 },
41 : { -2, -3, 24, 62, 46, 5, -4, 0 }, { -2, -3, 23, 61, 47, 6, -4, 0 },
42 : { -2, -3, 21, 60, 49, 7, -4, 0 }, { -1, -4, 20, 60, 50, 8, -4, -1 },
43 : { -1, -4, 19, 59, 51, 9, -4, -1 }, { -1, -4, 17, 58, 52, 10, -4, 0 },
44 : { -1, -4, 16, 57, 53, 12, -4, -1 }, { -1, -4, 15, 56, 54, 13, -4, -1 },
45 : { -1, -4, 14, 55, 55, 14, -4, -1 }, { -1, -4, 13, 54, 56, 15, -4, -1 },
46 : { -1, -4, 12, 53, 57, 16, -4, -1 }, { 0, -4, 10, 52, 58, 17, -4, -1 },
47 : { -1, -4, 9, 51, 59, 19, -4, -1 }, { -1, -4, 8, 50, 60, 20, -4, -1 },
48 : { 0, -4, 7, 49, 60, 21, -3, -2 }, { 0, -4, 6, 47, 61, 23, -3, -2 },
49 : { 0, -4, 5, 46, 62, 24, -3, -2 }, { 0, -4, 5, 45, 62, 25, -3, -2 },
50 : { 0, -4, 4, 43, 63, 27, -3, -2 }, { 0, -4, 3, 42, 63, 28, -2, -2 },
51 : { 0, -3, 2, 41, 63, 29, -2, -2 }, { 0, -3, 2, 39, 63, 31, -2, -2 },
52 : { 0, -3, 1, 38, 64, 32, -1, -3 }, { 0, -3, 1, 36, 64, 34, -1, -3 }
53 : };
54 :
55 : // Filters for interpolation (0.625-band) - note this also filters integer pels.
56 : static const interp_kernel filteredinterp_filters625[(1 << SUBPEL_BITS)] = {
57 : { -1, -8, 33, 80, 33, -8, -1, 0 }, { -1, -8, 30, 80, 35, -8, -1, 1 },
58 : { -1, -8, 28, 80, 37, -7, -2, 1 }, { 0, -8, 26, 79, 39, -7, -2, 1 },
59 : { 0, -8, 24, 79, 41, -7, -2, 1 }, { 0, -8, 22, 78, 43, -6, -2, 1 },
60 : { 0, -8, 20, 78, 45, -5, -3, 1 }, { 0, -8, 18, 77, 48, -5, -3, 1 },
61 : { 0, -8, 16, 76, 50, -4, -3, 1 }, { 0, -8, 15, 75, 52, -3, -4, 1 },
62 : { 0, -7, 13, 74, 54, -3, -4, 1 }, { 0, -7, 11, 73, 56, -2, -4, 1 },
63 : { 0, -7, 10, 71, 58, -1, -4, 1 }, { 1, -7, 8, 70, 60, 0, -5, 1 },
64 : { 1, -6, 6, 68, 62, 1, -5, 1 }, { 1, -6, 5, 67, 63, 2, -5, 1 },
65 : { 1, -6, 4, 65, 65, 4, -6, 1 }, { 1, -5, 2, 63, 67, 5, -6, 1 },
66 : { 1, -5, 1, 62, 68, 6, -6, 1 }, { 1, -5, 0, 60, 70, 8, -7, 1 },
67 : { 1, -4, -1, 58, 71, 10, -7, 0 }, { 1, -4, -2, 56, 73, 11, -7, 0 },
68 : { 1, -4, -3, 54, 74, 13, -7, 0 }, { 1, -4, -3, 52, 75, 15, -8, 0 },
69 : { 1, -3, -4, 50, 76, 16, -8, 0 }, { 1, -3, -5, 48, 77, 18, -8, 0 },
70 : { 1, -3, -5, 45, 78, 20, -8, 0 }, { 1, -2, -6, 43, 78, 22, -8, 0 },
71 : { 1, -2, -7, 41, 79, 24, -8, 0 }, { 1, -2, -7, 39, 79, 26, -8, 0 },
72 : { 1, -2, -7, 37, 80, 28, -8, -1 }, { 1, -1, -8, 35, 80, 30, -8, -1 },
73 : };
74 :
75 : // Filters for interpolation (0.75-band) - note this also filters integer pels.
76 : static const interp_kernel filteredinterp_filters750[(1 << SUBPEL_BITS)] = {
77 : { 2, -11, 25, 96, 25, -11, 2, 0 }, { 2, -11, 22, 96, 28, -11, 2, 0 },
78 : { 2, -10, 19, 95, 31, -11, 2, 0 }, { 2, -10, 17, 95, 34, -12, 2, 0 },
79 : { 2, -9, 14, 94, 37, -12, 2, 0 }, { 2, -8, 12, 93, 40, -12, 1, 0 },
80 : { 2, -8, 9, 92, 43, -12, 1, 1 }, { 2, -7, 7, 91, 46, -12, 1, 0 },
81 : { 2, -7, 5, 90, 49, -12, 1, 0 }, { 2, -6, 3, 88, 52, -12, 0, 1 },
82 : { 2, -5, 1, 86, 55, -12, 0, 1 }, { 2, -5, -1, 84, 58, -11, 0, 1 },
83 : { 2, -4, -2, 82, 61, -11, -1, 1 }, { 2, -4, -4, 80, 64, -10, -1, 1 },
84 : { 1, -3, -5, 77, 67, -9, -1, 1 }, { 1, -3, -6, 75, 70, -8, -2, 1 },
85 : { 1, -2, -7, 72, 72, -7, -2, 1 }, { 1, -2, -8, 70, 75, -6, -3, 1 },
86 : { 1, -1, -9, 67, 77, -5, -3, 1 }, { 1, -1, -10, 64, 80, -4, -4, 2 },
87 : { 1, -1, -11, 61, 82, -2, -4, 2 }, { 1, 0, -11, 58, 84, -1, -5, 2 },
88 : { 1, 0, -12, 55, 86, 1, -5, 2 }, { 1, 0, -12, 52, 88, 3, -6, 2 },
89 : { 0, 1, -12, 49, 90, 5, -7, 2 }, { 0, 1, -12, 46, 91, 7, -7, 2 },
90 : { 1, 1, -12, 43, 92, 9, -8, 2 }, { 0, 1, -12, 40, 93, 12, -8, 2 },
91 : { 0, 2, -12, 37, 94, 14, -9, 2 }, { 0, 2, -12, 34, 95, 17, -10, 2 },
92 : { 0, 2, -11, 31, 95, 19, -10, 2 }, { 0, 2, -11, 28, 96, 22, -11, 2 }
93 : };
94 :
95 : // Filters for interpolation (0.875-band) - note this also filters integer pels.
96 : static const interp_kernel filteredinterp_filters875[(1 << SUBPEL_BITS)] = {
97 : { 3, -8, 13, 112, 13, -8, 3, 0 }, { 3, -7, 10, 112, 17, -9, 3, -1 },
98 : { 2, -6, 7, 111, 21, -9, 3, -1 }, { 2, -5, 4, 111, 24, -10, 3, -1 },
99 : { 2, -4, 1, 110, 28, -11, 3, -1 }, { 1, -3, -1, 108, 32, -12, 4, -1 },
100 : { 1, -2, -3, 106, 36, -13, 4, -1 }, { 1, -1, -6, 105, 40, -14, 4, -1 },
101 : { 1, -1, -7, 102, 44, -14, 4, -1 }, { 1, 0, -9, 100, 48, -15, 4, -1 },
102 : { 1, 1, -11, 97, 53, -16, 4, -1 }, { 0, 1, -12, 95, 57, -16, 4, -1 },
103 : { 0, 2, -13, 91, 61, -16, 4, -1 }, { 0, 2, -14, 88, 65, -16, 4, -1 },
104 : { 0, 3, -15, 84, 69, -17, 4, 0 }, { 0, 3, -16, 81, 73, -16, 3, 0 },
105 : { 0, 3, -16, 77, 77, -16, 3, 0 }, { 0, 3, -16, 73, 81, -16, 3, 0 },
106 : { 0, 4, -17, 69, 84, -15, 3, 0 }, { -1, 4, -16, 65, 88, -14, 2, 0 },
107 : { -1, 4, -16, 61, 91, -13, 2, 0 }, { -1, 4, -16, 57, 95, -12, 1, 0 },
108 : { -1, 4, -16, 53, 97, -11, 1, 1 }, { -1, 4, -15, 48, 100, -9, 0, 1 },
109 : { -1, 4, -14, 44, 102, -7, -1, 1 }, { -1, 4, -14, 40, 105, -6, -1, 1 },
110 : { -1, 4, -13, 36, 106, -3, -2, 1 }, { -1, 4, -12, 32, 108, -1, -3, 1 },
111 : { -1, 3, -11, 28, 110, 1, -4, 2 }, { -1, 3, -10, 24, 111, 4, -5, 2 },
112 : { -1, 3, -9, 21, 111, 7, -6, 2 }, { -1, 3, -9, 17, 112, 10, -7, 3 }
113 : };
114 :
115 : // Filters for interpolation (full-band) - no filtering for integer pixels
116 : static const interp_kernel filteredinterp_filters1000[(1 << SUBPEL_BITS)] = {
117 : { 0, 0, 0, 128, 0, 0, 0, 0 }, { 0, 1, -3, 128, 3, -1, 0, 0 },
118 : { -1, 2, -6, 127, 7, -2, 1, 0 }, { -1, 3, -9, 126, 12, -4, 1, 0 },
119 : { -1, 4, -12, 125, 16, -5, 1, 0 }, { -1, 4, -14, 123, 20, -6, 2, 0 },
120 : { -1, 5, -15, 120, 25, -8, 2, 0 }, { -1, 5, -17, 118, 30, -9, 3, -1 },
121 : { -1, 6, -18, 114, 35, -10, 3, -1 }, { -1, 6, -19, 111, 41, -12, 3, -1 },
122 : { -1, 6, -20, 107, 46, -13, 4, -1 }, { -1, 6, -21, 103, 52, -14, 4, -1 },
123 : { -1, 6, -21, 99, 57, -16, 5, -1 }, { -1, 6, -21, 94, 63, -17, 5, -1 },
124 : { -1, 6, -20, 89, 68, -18, 5, -1 }, { -1, 6, -20, 84, 73, -19, 6, -1 },
125 : { -1, 6, -20, 79, 79, -20, 6, -1 }, { -1, 6, -19, 73, 84, -20, 6, -1 },
126 : { -1, 5, -18, 68, 89, -20, 6, -1 }, { -1, 5, -17, 63, 94, -21, 6, -1 },
127 : { -1, 5, -16, 57, 99, -21, 6, -1 }, { -1, 4, -14, 52, 103, -21, 6, -1 },
128 : { -1, 4, -13, 46, 107, -20, 6, -1 }, { -1, 3, -12, 41, 111, -19, 6, -1 },
129 : { -1, 3, -10, 35, 114, -18, 6, -1 }, { -1, 3, -9, 30, 118, -17, 5, -1 },
130 : { 0, 2, -8, 25, 120, -15, 5, -1 }, { 0, 2, -6, 20, 123, -14, 4, -1 },
131 : { 0, 1, -5, 16, 125, -12, 4, -1 }, { 0, 1, -4, 12, 126, -9, 3, -1 },
132 : { 0, 1, -2, 7, 127, -6, 2, -1 }, { 0, 0, -1, 3, 128, -3, 1, 0 }
133 : };
134 :
135 : // Filters for factor of 2 downsampling.
136 : static const int16_t vp9_down2_symeven_half_filter[] = { 56, 12, -3, -1 };
137 : static const int16_t vp9_down2_symodd_half_filter[] = { 64, 35, 0, -3 };
138 :
139 0 : static const interp_kernel *choose_interp_filter(int inlength, int outlength) {
140 0 : int outlength16 = outlength * 16;
141 0 : if (outlength16 >= inlength * 16)
142 0 : return filteredinterp_filters1000;
143 0 : else if (outlength16 >= inlength * 13)
144 0 : return filteredinterp_filters875;
145 0 : else if (outlength16 >= inlength * 11)
146 0 : return filteredinterp_filters750;
147 0 : else if (outlength16 >= inlength * 9)
148 0 : return filteredinterp_filters625;
149 : else
150 0 : return filteredinterp_filters500;
151 : }
152 :
153 0 : static void interpolate(const uint8_t *const input, int inlength,
154 : uint8_t *output, int outlength) {
155 0 : const int64_t delta =
156 0 : (((uint64_t)inlength << 32) + outlength / 2) / outlength;
157 0 : const int64_t offset =
158 : inlength > outlength
159 0 : ? (((int64_t)(inlength - outlength) << 31) + outlength / 2) /
160 : outlength
161 0 : : -(((int64_t)(outlength - inlength) << 31) + outlength / 2) /
162 : outlength;
163 0 : uint8_t *optr = output;
164 : int x, x1, x2, sum, k, int_pel, sub_pel;
165 : int64_t y;
166 :
167 0 : const interp_kernel *interp_filters =
168 : choose_interp_filter(inlength, outlength);
169 :
170 0 : x = 0;
171 0 : y = offset;
172 0 : while ((y >> INTERP_PRECISION_BITS) < (INTERP_TAPS / 2 - 1)) {
173 0 : x++;
174 0 : y += delta;
175 : }
176 0 : x1 = x;
177 0 : x = outlength - 1;
178 0 : y = delta * x + offset;
179 0 : while ((y >> INTERP_PRECISION_BITS) + (int64_t)(INTERP_TAPS / 2) >=
180 : inlength) {
181 0 : x--;
182 0 : y -= delta;
183 : }
184 0 : x2 = x;
185 0 : if (x1 > x2) {
186 0 : for (x = 0, y = offset; x < outlength; ++x, y += delta) {
187 : const int16_t *filter;
188 0 : int_pel = y >> INTERP_PRECISION_BITS;
189 0 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
190 0 : filter = interp_filters[sub_pel];
191 0 : sum = 0;
192 0 : for (k = 0; k < INTERP_TAPS; ++k) {
193 0 : const int pk = int_pel - INTERP_TAPS / 2 + 1 + k;
194 0 : sum += filter[k] *
195 0 : input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1 : pk))];
196 : }
197 0 : *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
198 : }
199 : } else {
200 : // Initial part.
201 0 : for (x = 0, y = offset; x < x1; ++x, y += delta) {
202 : const int16_t *filter;
203 0 : int_pel = y >> INTERP_PRECISION_BITS;
204 0 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
205 0 : filter = interp_filters[sub_pel];
206 0 : sum = 0;
207 0 : for (k = 0; k < INTERP_TAPS; ++k)
208 0 : sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k < 0
209 : ? 0
210 0 : : int_pel - INTERP_TAPS / 2 + 1 + k)];
211 0 : *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
212 : }
213 : // Middle part.
214 0 : for (; x <= x2; ++x, y += delta) {
215 : const int16_t *filter;
216 0 : int_pel = y >> INTERP_PRECISION_BITS;
217 0 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
218 0 : filter = interp_filters[sub_pel];
219 0 : sum = 0;
220 0 : for (k = 0; k < INTERP_TAPS; ++k)
221 0 : sum += filter[k] * input[int_pel - INTERP_TAPS / 2 + 1 + k];
222 0 : *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
223 : }
224 : // End part.
225 0 : for (; x < outlength; ++x, y += delta) {
226 : const int16_t *filter;
227 0 : int_pel = y >> INTERP_PRECISION_BITS;
228 0 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
229 0 : filter = interp_filters[sub_pel];
230 0 : sum = 0;
231 0 : for (k = 0; k < INTERP_TAPS; ++k)
232 0 : sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k >= inlength
233 0 : ? inlength - 1
234 0 : : int_pel - INTERP_TAPS / 2 + 1 + k)];
235 0 : *optr++ = clip_pixel(ROUND_POWER_OF_TWO(sum, FILTER_BITS));
236 : }
237 : }
238 0 : }
239 :
240 0 : static void down2_symeven(const uint8_t *const input, int length,
241 : uint8_t *output) {
242 : // Actual filter len = 2 * filter_len_half.
243 0 : const int16_t *filter = vp9_down2_symeven_half_filter;
244 0 : const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;
245 : int i, j;
246 0 : uint8_t *optr = output;
247 0 : int l1 = filter_len_half;
248 0 : int l2 = (length - filter_len_half);
249 0 : l1 += (l1 & 1);
250 0 : l2 += (l2 & 1);
251 0 : if (l1 > l2) {
252 : // Short input length.
253 0 : for (i = 0; i < length; i += 2) {
254 0 : int sum = (1 << (FILTER_BITS - 1));
255 0 : for (j = 0; j < filter_len_half; ++j) {
256 0 : sum += (input[(i - j < 0 ? 0 : i - j)] +
257 0 : input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
258 0 : filter[j];
259 : }
260 0 : sum >>= FILTER_BITS;
261 0 : *optr++ = clip_pixel(sum);
262 : }
263 : } else {
264 : // Initial part.
265 0 : for (i = 0; i < l1; i += 2) {
266 0 : int sum = (1 << (FILTER_BITS - 1));
267 0 : for (j = 0; j < filter_len_half; ++j) {
268 0 : sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + 1 + j]) * filter[j];
269 : }
270 0 : sum >>= FILTER_BITS;
271 0 : *optr++ = clip_pixel(sum);
272 : }
273 : // Middle part.
274 0 : for (; i < l2; i += 2) {
275 0 : int sum = (1 << (FILTER_BITS - 1));
276 0 : for (j = 0; j < filter_len_half; ++j) {
277 0 : sum += (input[i - j] + input[i + 1 + j]) * filter[j];
278 : }
279 0 : sum >>= FILTER_BITS;
280 0 : *optr++ = clip_pixel(sum);
281 : }
282 : // End part.
283 0 : for (; i < length; i += 2) {
284 0 : int sum = (1 << (FILTER_BITS - 1));
285 0 : for (j = 0; j < filter_len_half; ++j) {
286 0 : sum += (input[i - j] +
287 0 : input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
288 0 : filter[j];
289 : }
290 0 : sum >>= FILTER_BITS;
291 0 : *optr++ = clip_pixel(sum);
292 : }
293 : }
294 0 : }
295 :
296 0 : static void down2_symodd(const uint8_t *const input, int length,
297 : uint8_t *output) {
298 : // Actual filter len = 2 * filter_len_half - 1.
299 0 : const int16_t *filter = vp9_down2_symodd_half_filter;
300 0 : const int filter_len_half = sizeof(vp9_down2_symodd_half_filter) / 2;
301 : int i, j;
302 0 : uint8_t *optr = output;
303 0 : int l1 = filter_len_half - 1;
304 0 : int l2 = (length - filter_len_half + 1);
305 0 : l1 += (l1 & 1);
306 0 : l2 += (l2 & 1);
307 0 : if (l1 > l2) {
308 : // Short input length.
309 0 : for (i = 0; i < length; i += 2) {
310 0 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
311 0 : for (j = 1; j < filter_len_half; ++j) {
312 0 : sum += (input[(i - j < 0 ? 0 : i - j)] +
313 0 : input[(i + j >= length ? length - 1 : i + j)]) *
314 0 : filter[j];
315 : }
316 0 : sum >>= FILTER_BITS;
317 0 : *optr++ = clip_pixel(sum);
318 : }
319 : } else {
320 : // Initial part.
321 0 : for (i = 0; i < l1; i += 2) {
322 0 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
323 0 : for (j = 1; j < filter_len_half; ++j) {
324 0 : sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + j]) * filter[j];
325 : }
326 0 : sum >>= FILTER_BITS;
327 0 : *optr++ = clip_pixel(sum);
328 : }
329 : // Middle part.
330 0 : for (; i < l2; i += 2) {
331 0 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
332 0 : for (j = 1; j < filter_len_half; ++j) {
333 0 : sum += (input[i - j] + input[i + j]) * filter[j];
334 : }
335 0 : sum >>= FILTER_BITS;
336 0 : *optr++ = clip_pixel(sum);
337 : }
338 : // End part.
339 0 : for (; i < length; i += 2) {
340 0 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
341 0 : for (j = 1; j < filter_len_half; ++j) {
342 0 : sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)]) *
343 0 : filter[j];
344 : }
345 0 : sum >>= FILTER_BITS;
346 0 : *optr++ = clip_pixel(sum);
347 : }
348 : }
349 0 : }
350 :
351 0 : static int get_down2_length(int length, int steps) {
352 : int s;
353 0 : for (s = 0; s < steps; ++s) length = (length + 1) >> 1;
354 0 : return length;
355 : }
356 :
357 0 : static int get_down2_steps(int in_length, int out_length) {
358 0 : int steps = 0;
359 : int proj_in_length;
360 0 : while ((proj_in_length = get_down2_length(in_length, 1)) >= out_length) {
361 0 : ++steps;
362 0 : in_length = proj_in_length;
363 : }
364 0 : return steps;
365 : }
366 :
367 0 : static void resize_multistep(const uint8_t *const input, int length,
368 : uint8_t *output, int olength, uint8_t *otmp) {
369 : int steps;
370 0 : if (length == olength) {
371 0 : memcpy(output, input, sizeof(output[0]) * length);
372 0 : return;
373 : }
374 0 : steps = get_down2_steps(length, olength);
375 :
376 0 : if (steps > 0) {
377 : int s;
378 0 : uint8_t *out = NULL;
379 : uint8_t *otmp2;
380 0 : int filteredlength = length;
381 :
382 0 : assert(otmp != NULL);
383 0 : otmp2 = otmp + get_down2_length(length, 1);
384 0 : for (s = 0; s < steps; ++s) {
385 0 : const int proj_filteredlength = get_down2_length(filteredlength, 1);
386 0 : const uint8_t *const in = (s == 0 ? input : out);
387 0 : if (s == steps - 1 && proj_filteredlength == olength)
388 0 : out = output;
389 : else
390 0 : out = (s & 1 ? otmp2 : otmp);
391 0 : if (filteredlength & 1)
392 0 : down2_symodd(in, filteredlength, out);
393 : else
394 0 : down2_symeven(in, filteredlength, out);
395 0 : filteredlength = proj_filteredlength;
396 : }
397 0 : if (filteredlength != olength) {
398 0 : interpolate(out, filteredlength, output, olength);
399 : }
400 : } else {
401 0 : interpolate(input, length, output, olength);
402 : }
403 : }
404 :
405 0 : static void fill_col_to_arr(uint8_t *img, int stride, int len, uint8_t *arr) {
406 : int i;
407 0 : uint8_t *iptr = img;
408 0 : uint8_t *aptr = arr;
409 0 : for (i = 0; i < len; ++i, iptr += stride) {
410 0 : *aptr++ = *iptr;
411 : }
412 0 : }
413 :
414 0 : static void fill_arr_to_col(uint8_t *img, int stride, int len, uint8_t *arr) {
415 : int i;
416 0 : uint8_t *iptr = img;
417 0 : uint8_t *aptr = arr;
418 0 : for (i = 0; i < len; ++i, iptr += stride) {
419 0 : *iptr = *aptr++;
420 : }
421 0 : }
422 :
423 0 : void vp9_resize_plane(const uint8_t *const input, int height, int width,
424 : int in_stride, uint8_t *output, int height2, int width2,
425 : int out_stride) {
426 : int i;
427 0 : uint8_t *intbuf = (uint8_t *)malloc(sizeof(uint8_t) * width2 * height);
428 0 : uint8_t *tmpbuf =
429 0 : (uint8_t *)malloc(sizeof(uint8_t) * (width < height ? height : width));
430 0 : uint8_t *arrbuf = (uint8_t *)malloc(sizeof(uint8_t) * height);
431 0 : uint8_t *arrbuf2 = (uint8_t *)malloc(sizeof(uint8_t) * height2);
432 0 : if (intbuf == NULL || tmpbuf == NULL || arrbuf == NULL || arrbuf2 == NULL)
433 : goto Error;
434 0 : assert(width > 0);
435 0 : assert(height > 0);
436 0 : assert(width2 > 0);
437 0 : assert(height2 > 0);
438 0 : for (i = 0; i < height; ++i)
439 0 : resize_multistep(input + in_stride * i, width, intbuf + width2 * i, width2,
440 : tmpbuf);
441 0 : for (i = 0; i < width2; ++i) {
442 0 : fill_col_to_arr(intbuf + i, width2, height, arrbuf);
443 0 : resize_multistep(arrbuf, height, arrbuf2, height2, tmpbuf);
444 0 : fill_arr_to_col(output + i, out_stride, height2, arrbuf2);
445 : }
446 :
447 : Error:
448 0 : free(intbuf);
449 0 : free(tmpbuf);
450 0 : free(arrbuf);
451 0 : free(arrbuf2);
452 0 : }
453 :
454 : #if CONFIG_VP9_HIGHBITDEPTH
455 : static void highbd_interpolate(const uint16_t *const input, int inlength,
456 : uint16_t *output, int outlength, int bd) {
457 : const int64_t delta =
458 : (((uint64_t)inlength << 32) + outlength / 2) / outlength;
459 : const int64_t offset =
460 : inlength > outlength
461 : ? (((int64_t)(inlength - outlength) << 31) + outlength / 2) /
462 : outlength
463 : : -(((int64_t)(outlength - inlength) << 31) + outlength / 2) /
464 : outlength;
465 : uint16_t *optr = output;
466 : int x, x1, x2, sum, k, int_pel, sub_pel;
467 : int64_t y;
468 :
469 : const interp_kernel *interp_filters =
470 : choose_interp_filter(inlength, outlength);
471 :
472 : x = 0;
473 : y = offset;
474 : while ((y >> INTERP_PRECISION_BITS) < (INTERP_TAPS / 2 - 1)) {
475 : x++;
476 : y += delta;
477 : }
478 : x1 = x;
479 : x = outlength - 1;
480 : y = delta * x + offset;
481 : while ((y >> INTERP_PRECISION_BITS) + (int64_t)(INTERP_TAPS / 2) >=
482 : inlength) {
483 : x--;
484 : y -= delta;
485 : }
486 : x2 = x;
487 : if (x1 > x2) {
488 : for (x = 0, y = offset; x < outlength; ++x, y += delta) {
489 : const int16_t *filter;
490 : int_pel = y >> INTERP_PRECISION_BITS;
491 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
492 : filter = interp_filters[sub_pel];
493 : sum = 0;
494 : for (k = 0; k < INTERP_TAPS; ++k) {
495 : const int pk = int_pel - INTERP_TAPS / 2 + 1 + k;
496 : sum += filter[k] *
497 : input[(pk < 0 ? 0 : (pk >= inlength ? inlength - 1 : pk))];
498 : }
499 : *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
500 : }
501 : } else {
502 : // Initial part.
503 : for (x = 0, y = offset; x < x1; ++x, y += delta) {
504 : const int16_t *filter;
505 : int_pel = y >> INTERP_PRECISION_BITS;
506 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
507 : filter = interp_filters[sub_pel];
508 : sum = 0;
509 : for (k = 0; k < INTERP_TAPS; ++k)
510 : sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k < 0
511 : ? 0
512 : : int_pel - INTERP_TAPS / 2 + 1 + k)];
513 : *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
514 : }
515 : // Middle part.
516 : for (; x <= x2; ++x, y += delta) {
517 : const int16_t *filter;
518 : int_pel = y >> INTERP_PRECISION_BITS;
519 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
520 : filter = interp_filters[sub_pel];
521 : sum = 0;
522 : for (k = 0; k < INTERP_TAPS; ++k)
523 : sum += filter[k] * input[int_pel - INTERP_TAPS / 2 + 1 + k];
524 : *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
525 : }
526 : // End part.
527 : for (; x < outlength; ++x, y += delta) {
528 : const int16_t *filter;
529 : int_pel = y >> INTERP_PRECISION_BITS;
530 : sub_pel = (y >> (INTERP_PRECISION_BITS - SUBPEL_BITS)) & SUBPEL_MASK;
531 : filter = interp_filters[sub_pel];
532 : sum = 0;
533 : for (k = 0; k < INTERP_TAPS; ++k)
534 : sum += filter[k] * input[(int_pel - INTERP_TAPS / 2 + 1 + k >= inlength
535 : ? inlength - 1
536 : : int_pel - INTERP_TAPS / 2 + 1 + k)];
537 : *optr++ = clip_pixel_highbd(ROUND_POWER_OF_TWO(sum, FILTER_BITS), bd);
538 : }
539 : }
540 : }
541 :
542 : static void highbd_down2_symeven(const uint16_t *const input, int length,
543 : uint16_t *output, int bd) {
544 : // Actual filter len = 2 * filter_len_half.
545 : static const int16_t *filter = vp9_down2_symeven_half_filter;
546 : const int filter_len_half = sizeof(vp9_down2_symeven_half_filter) / 2;
547 : int i, j;
548 : uint16_t *optr = output;
549 : int l1 = filter_len_half;
550 : int l2 = (length - filter_len_half);
551 : l1 += (l1 & 1);
552 : l2 += (l2 & 1);
553 : if (l1 > l2) {
554 : // Short input length.
555 : for (i = 0; i < length; i += 2) {
556 : int sum = (1 << (FILTER_BITS - 1));
557 : for (j = 0; j < filter_len_half; ++j) {
558 : sum += (input[(i - j < 0 ? 0 : i - j)] +
559 : input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
560 : filter[j];
561 : }
562 : sum >>= FILTER_BITS;
563 : *optr++ = clip_pixel_highbd(sum, bd);
564 : }
565 : } else {
566 : // Initial part.
567 : for (i = 0; i < l1; i += 2) {
568 : int sum = (1 << (FILTER_BITS - 1));
569 : for (j = 0; j < filter_len_half; ++j) {
570 : sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + 1 + j]) * filter[j];
571 : }
572 : sum >>= FILTER_BITS;
573 : *optr++ = clip_pixel_highbd(sum, bd);
574 : }
575 : // Middle part.
576 : for (; i < l2; i += 2) {
577 : int sum = (1 << (FILTER_BITS - 1));
578 : for (j = 0; j < filter_len_half; ++j) {
579 : sum += (input[i - j] + input[i + 1 + j]) * filter[j];
580 : }
581 : sum >>= FILTER_BITS;
582 : *optr++ = clip_pixel_highbd(sum, bd);
583 : }
584 : // End part.
585 : for (; i < length; i += 2) {
586 : int sum = (1 << (FILTER_BITS - 1));
587 : for (j = 0; j < filter_len_half; ++j) {
588 : sum += (input[i - j] +
589 : input[(i + 1 + j >= length ? length - 1 : i + 1 + j)]) *
590 : filter[j];
591 : }
592 : sum >>= FILTER_BITS;
593 : *optr++ = clip_pixel_highbd(sum, bd);
594 : }
595 : }
596 : }
597 :
598 : static void highbd_down2_symodd(const uint16_t *const input, int length,
599 : uint16_t *output, int bd) {
600 : // Actual filter len = 2 * filter_len_half - 1.
601 : static const int16_t *filter = vp9_down2_symodd_half_filter;
602 : const int filter_len_half = sizeof(vp9_down2_symodd_half_filter) / 2;
603 : int i, j;
604 : uint16_t *optr = output;
605 : int l1 = filter_len_half - 1;
606 : int l2 = (length - filter_len_half + 1);
607 : l1 += (l1 & 1);
608 : l2 += (l2 & 1);
609 : if (l1 > l2) {
610 : // Short input length.
611 : for (i = 0; i < length; i += 2) {
612 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
613 : for (j = 1; j < filter_len_half; ++j) {
614 : sum += (input[(i - j < 0 ? 0 : i - j)] +
615 : input[(i + j >= length ? length - 1 : i + j)]) *
616 : filter[j];
617 : }
618 : sum >>= FILTER_BITS;
619 : *optr++ = clip_pixel_highbd(sum, bd);
620 : }
621 : } else {
622 : // Initial part.
623 : for (i = 0; i < l1; i += 2) {
624 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
625 : for (j = 1; j < filter_len_half; ++j) {
626 : sum += (input[(i - j < 0 ? 0 : i - j)] + input[i + j]) * filter[j];
627 : }
628 : sum >>= FILTER_BITS;
629 : *optr++ = clip_pixel_highbd(sum, bd);
630 : }
631 : // Middle part.
632 : for (; i < l2; i += 2) {
633 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
634 : for (j = 1; j < filter_len_half; ++j) {
635 : sum += (input[i - j] + input[i + j]) * filter[j];
636 : }
637 : sum >>= FILTER_BITS;
638 : *optr++ = clip_pixel_highbd(sum, bd);
639 : }
640 : // End part.
641 : for (; i < length; i += 2) {
642 : int sum = (1 << (FILTER_BITS - 1)) + input[i] * filter[0];
643 : for (j = 1; j < filter_len_half; ++j) {
644 : sum += (input[i - j] + input[(i + j >= length ? length - 1 : i + j)]) *
645 : filter[j];
646 : }
647 : sum >>= FILTER_BITS;
648 : *optr++ = clip_pixel_highbd(sum, bd);
649 : }
650 : }
651 : }
652 :
653 : static void highbd_resize_multistep(const uint16_t *const input, int length,
654 : uint16_t *output, int olength,
655 : uint16_t *otmp, int bd) {
656 : int steps;
657 : if (length == olength) {
658 : memcpy(output, input, sizeof(output[0]) * length);
659 : return;
660 : }
661 : steps = get_down2_steps(length, olength);
662 :
663 : if (steps > 0) {
664 : int s;
665 : uint16_t *out = NULL;
666 : uint16_t *otmp2;
667 : int filteredlength = length;
668 :
669 : assert(otmp != NULL);
670 : otmp2 = otmp + get_down2_length(length, 1);
671 : for (s = 0; s < steps; ++s) {
672 : const int proj_filteredlength = get_down2_length(filteredlength, 1);
673 : const uint16_t *const in = (s == 0 ? input : out);
674 : if (s == steps - 1 && proj_filteredlength == olength)
675 : out = output;
676 : else
677 : out = (s & 1 ? otmp2 : otmp);
678 : if (filteredlength & 1)
679 : highbd_down2_symodd(in, filteredlength, out, bd);
680 : else
681 : highbd_down2_symeven(in, filteredlength, out, bd);
682 : filteredlength = proj_filteredlength;
683 : }
684 : if (filteredlength != olength) {
685 : highbd_interpolate(out, filteredlength, output, olength, bd);
686 : }
687 : } else {
688 : highbd_interpolate(input, length, output, olength, bd);
689 : }
690 : }
691 :
692 : static void highbd_fill_col_to_arr(uint16_t *img, int stride, int len,
693 : uint16_t *arr) {
694 : int i;
695 : uint16_t *iptr = img;
696 : uint16_t *aptr = arr;
697 : for (i = 0; i < len; ++i, iptr += stride) {
698 : *aptr++ = *iptr;
699 : }
700 : }
701 :
702 : static void highbd_fill_arr_to_col(uint16_t *img, int stride, int len,
703 : uint16_t *arr) {
704 : int i;
705 : uint16_t *iptr = img;
706 : uint16_t *aptr = arr;
707 : for (i = 0; i < len; ++i, iptr += stride) {
708 : *iptr = *aptr++;
709 : }
710 : }
711 :
712 : void vp9_highbd_resize_plane(const uint8_t *const input, int height, int width,
713 : int in_stride, uint8_t *output, int height2,
714 : int width2, int out_stride, int bd) {
715 : int i;
716 : uint16_t *intbuf = (uint16_t *)malloc(sizeof(uint16_t) * width2 * height);
717 : uint16_t *tmpbuf =
718 : (uint16_t *)malloc(sizeof(uint16_t) * (width < height ? height : width));
719 : uint16_t *arrbuf = (uint16_t *)malloc(sizeof(uint16_t) * height);
720 : uint16_t *arrbuf2 = (uint16_t *)malloc(sizeof(uint16_t) * height2);
721 : if (intbuf == NULL || tmpbuf == NULL || arrbuf == NULL || arrbuf2 == NULL)
722 : goto Error;
723 : for (i = 0; i < height; ++i) {
724 : highbd_resize_multistep(CONVERT_TO_SHORTPTR(input + in_stride * i), width,
725 : intbuf + width2 * i, width2, tmpbuf, bd);
726 : }
727 : for (i = 0; i < width2; ++i) {
728 : highbd_fill_col_to_arr(intbuf + i, width2, height, arrbuf);
729 : highbd_resize_multistep(arrbuf, height, arrbuf2, height2, tmpbuf, bd);
730 : highbd_fill_arr_to_col(CONVERT_TO_SHORTPTR(output + i), out_stride, height2,
731 : arrbuf2);
732 : }
733 :
734 : Error:
735 : free(intbuf);
736 : free(tmpbuf);
737 : free(arrbuf);
738 : free(arrbuf2);
739 : }
740 : #endif // CONFIG_VP9_HIGHBITDEPTH
741 :
742 0 : void vp9_resize_frame420(const uint8_t *const y, int y_stride,
743 : const uint8_t *const u, const uint8_t *const v,
744 : int uv_stride, int height, int width, uint8_t *oy,
745 : int oy_stride, uint8_t *ou, uint8_t *ov,
746 : int ouv_stride, int oheight, int owidth) {
747 0 : vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
748 0 : vp9_resize_plane(u, height / 2, width / 2, uv_stride, ou, oheight / 2,
749 : owidth / 2, ouv_stride);
750 0 : vp9_resize_plane(v, height / 2, width / 2, uv_stride, ov, oheight / 2,
751 : owidth / 2, ouv_stride);
752 0 : }
753 :
754 0 : void vp9_resize_frame422(const uint8_t *const y, int y_stride,
755 : const uint8_t *const u, const uint8_t *const v,
756 : int uv_stride, int height, int width, uint8_t *oy,
757 : int oy_stride, uint8_t *ou, uint8_t *ov,
758 : int ouv_stride, int oheight, int owidth) {
759 0 : vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
760 0 : vp9_resize_plane(u, height, width / 2, uv_stride, ou, oheight, owidth / 2,
761 : ouv_stride);
762 0 : vp9_resize_plane(v, height, width / 2, uv_stride, ov, oheight, owidth / 2,
763 : ouv_stride);
764 0 : }
765 :
766 0 : void vp9_resize_frame444(const uint8_t *const y, int y_stride,
767 : const uint8_t *const u, const uint8_t *const v,
768 : int uv_stride, int height, int width, uint8_t *oy,
769 : int oy_stride, uint8_t *ou, uint8_t *ov,
770 : int ouv_stride, int oheight, int owidth) {
771 0 : vp9_resize_plane(y, height, width, y_stride, oy, oheight, owidth, oy_stride);
772 0 : vp9_resize_plane(u, height, width, uv_stride, ou, oheight, owidth,
773 : ouv_stride);
774 0 : vp9_resize_plane(v, height, width, uv_stride, ov, oheight, owidth,
775 : ouv_stride);
776 0 : }
777 :
778 : #if CONFIG_VP9_HIGHBITDEPTH
779 : void vp9_highbd_resize_frame420(const uint8_t *const y, int y_stride,
780 : const uint8_t *const u, const uint8_t *const v,
781 : int uv_stride, int height, int width,
782 : uint8_t *oy, int oy_stride, uint8_t *ou,
783 : uint8_t *ov, int ouv_stride, int oheight,
784 : int owidth, int bd) {
785 : vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
786 : oy_stride, bd);
787 : vp9_highbd_resize_plane(u, height / 2, width / 2, uv_stride, ou, oheight / 2,
788 : owidth / 2, ouv_stride, bd);
789 : vp9_highbd_resize_plane(v, height / 2, width / 2, uv_stride, ov, oheight / 2,
790 : owidth / 2, ouv_stride, bd);
791 : }
792 :
793 : void vp9_highbd_resize_frame422(const uint8_t *const y, int y_stride,
794 : const uint8_t *const u, const uint8_t *const v,
795 : int uv_stride, int height, int width,
796 : uint8_t *oy, int oy_stride, uint8_t *ou,
797 : uint8_t *ov, int ouv_stride, int oheight,
798 : int owidth, int bd) {
799 : vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
800 : oy_stride, bd);
801 : vp9_highbd_resize_plane(u, height, width / 2, uv_stride, ou, oheight,
802 : owidth / 2, ouv_stride, bd);
803 : vp9_highbd_resize_plane(v, height, width / 2, uv_stride, ov, oheight,
804 : owidth / 2, ouv_stride, bd);
805 : }
806 :
807 : void vp9_highbd_resize_frame444(const uint8_t *const y, int y_stride,
808 : const uint8_t *const u, const uint8_t *const v,
809 : int uv_stride, int height, int width,
810 : uint8_t *oy, int oy_stride, uint8_t *ou,
811 : uint8_t *ov, int ouv_stride, int oheight,
812 : int owidth, int bd) {
813 : vp9_highbd_resize_plane(y, height, width, y_stride, oy, oheight, owidth,
814 : oy_stride, bd);
815 : vp9_highbd_resize_plane(u, height, width, uv_stride, ou, oheight, owidth,
816 : ouv_stride, bd);
817 : vp9_highbd_resize_plane(v, height, width, uv_stride, ov, oheight, owidth,
818 : ouv_stride, bd);
819 : }
820 : #endif // CONFIG_VP9_HIGHBITDEPTH
|
