1 /*
2 * Copyright 2012-16 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: AMD
23 *
24 */
25 #include "transform.h"
26
27 //=========================================
28 // <num_taps> = 2
29 // <num_phases> = 16
30 // <scale_ratio> = 0.833333 (input/output)
31 // <sharpness> = 0
32 // <CoefType> = ModifiedLanczos
33 // <CoefQuant> = s1.10
34 // <CoefOut> = s1.12
35 //=========================================
36 static const uint16_t filter_2tap_16p[18] = {
37 0x1000, 0x0000,
38 0x0FF0, 0x0010,
39 0x0FB0, 0x0050,
40 0x0F34, 0x00CC,
41 0x0E68, 0x0198,
42 0x0D44, 0x02BC,
43 0x0BC4, 0x043C,
44 0x09FC, 0x0604,
45 0x0800, 0x0800
46 };
47
48 //=========================================
49 // <num_taps> = 3
50 // <num_phases> = 16
51 // <scale_ratio> = 0.83333 (input/output)
52 // <sharpness> = 0
53 // <CoefType> = ModifiedLanczos
54 // <CoefQuant> = 1.10
55 // <CoefOut> = 1.12
56 //=========================================
57 static const uint16_t filter_3tap_16p_upscale[27] = {
58 0x0804, 0x07FC, 0x0000,
59 0x06AC, 0x0978, 0x3FDC,
60 0x055C, 0x0AF0, 0x3FB4,
61 0x0420, 0x0C50, 0x3F90,
62 0x0300, 0x0D88, 0x3F78,
63 0x0200, 0x0E90, 0x3F70,
64 0x0128, 0x0F5C, 0x3F7C,
65 0x007C, 0x0FD8, 0x3FAC,
66 0x0000, 0x1000, 0x0000
67 };
68
69 //=========================================
70 // <num_taps> = 3
71 // <num_phases> = 16
72 // <scale_ratio> = 1.16666 (input/output)
73 // <sharpness> = 0
74 // <CoefType> = ModifiedLanczos
75 // <CoefQuant> = 1.10
76 // <CoefOut> = 1.12
77 //=========================================
78 static const uint16_t filter_3tap_16p_116[27] = {
79 0x0804, 0x07FC, 0x0000,
80 0x0700, 0x0914, 0x3FEC,
81 0x0604, 0x0A1C, 0x3FE0,
82 0x050C, 0x0B14, 0x3FE0,
83 0x041C, 0x0BF4, 0x3FF0,
84 0x0340, 0x0CB0, 0x0010,
85 0x0274, 0x0D3C, 0x0050,
86 0x01C0, 0x0D94, 0x00AC,
87 0x0128, 0x0DB4, 0x0124
88 };
89
90 //=========================================
91 // <num_taps> = 3
92 // <num_phases> = 16
93 // <scale_ratio> = 1.49999 (input/output)
94 // <sharpness> = 0
95 // <CoefType> = ModifiedLanczos
96 // <CoefQuant> = 1.10
97 // <CoefOut> = 1.12
98 //=========================================
99 static const uint16_t filter_3tap_16p_149[27] = {
100 0x0804, 0x07FC, 0x0000,
101 0x0730, 0x08CC, 0x0004,
102 0x0660, 0x098C, 0x0014,
103 0x0590, 0x0A3C, 0x0034,
104 0x04C4, 0x0AD4, 0x0068,
105 0x0400, 0x0B54, 0x00AC,
106 0x0348, 0x0BB0, 0x0108,
107 0x029C, 0x0BEC, 0x0178,
108 0x0200, 0x0C00, 0x0200
109 };
110
111 //=========================================
112 // <num_taps> = 3
113 // <num_phases> = 16
114 // <scale_ratio> = 1.83332 (input/output)
115 // <sharpness> = 0
116 // <CoefType> = ModifiedLanczos
117 // <CoefQuant> = 1.10
118 // <CoefOut> = 1.12
119 //=========================================
120 static const uint16_t filter_3tap_16p_183[27] = {
121 0x0804, 0x07FC, 0x0000,
122 0x0754, 0x0880, 0x002C,
123 0x06A8, 0x08F0, 0x0068,
124 0x05FC, 0x0954, 0x00B0,
125 0x0550, 0x09AC, 0x0104,
126 0x04A8, 0x09F0, 0x0168,
127 0x0408, 0x0A20, 0x01D8,
128 0x036C, 0x0A40, 0x0254,
129 0x02DC, 0x0A48, 0x02DC
130 };
131
132 //=========================================
133 // <num_taps> = 4
134 // <num_phases> = 16
135 // <scale_ratio> = 0.83333 (input/output)
136 // <sharpness> = 0
137 // <CoefType> = ModifiedLanczos
138 // <CoefQuant> = 1.10
139 // <CoefOut> = 1.12
140 //=========================================
141 static const uint16_t filter_4tap_16p_upscale[36] = {
142 0x0000, 0x1000, 0x0000, 0x0000,
143 0x3F74, 0x0FDC, 0x00B4, 0x3FFC,
144 0x3F0C, 0x0F70, 0x0194, 0x3FF0,
145 0x3ECC, 0x0EC4, 0x0298, 0x3FD8,
146 0x3EAC, 0x0DE4, 0x03B8, 0x3FB8,
147 0x3EA4, 0x0CD8, 0x04F4, 0x3F90,
148 0x3EB8, 0x0BA0, 0x0644, 0x3F64,
149 0x3ED8, 0x0A54, 0x07A0, 0x3F34,
150 0x3F00, 0x08FC, 0x0900, 0x3F04
151 };
152
153 //=========================================
154 // <num_taps> = 4
155 // <num_phases> = 16
156 // <scale_ratio> = 1.16666 (input/output)
157 // <sharpness> = 0
158 // <CoefType> = ModifiedLanczos
159 // <CoefQuant> = 1.10
160 // <CoefOut> = 1.12
161 //=========================================
162 static const uint16_t filter_4tap_16p_116[36] = {
163 0x01A8, 0x0CB4, 0x01A4, 0x0000,
164 0x0110, 0x0CB0, 0x0254, 0x3FEC,
165 0x0090, 0x0C80, 0x031C, 0x3FD4,
166 0x0024, 0x0C2C, 0x03F4, 0x3FBC,
167 0x3FD8, 0x0BAC, 0x04DC, 0x3FA0,
168 0x3F9C, 0x0B14, 0x05CC, 0x3F84,
169 0x3F70, 0x0A60, 0x06C4, 0x3F6C,
170 0x3F5C, 0x098C, 0x07BC, 0x3F5C,
171 0x3F54, 0x08AC, 0x08AC, 0x3F54
172 };
173
174 //=========================================
175 // <num_taps> = 4
176 // <num_phases> = 16
177 // <scale_ratio> = 1.49999 (input/output)
178 // <sharpness> = 0
179 // <CoefType> = ModifiedLanczos
180 // <CoefQuant> = 1.10
181 // <CoefOut> = 1.12
182 //=========================================
183 static const uint16_t filter_4tap_16p_149[36] = {
184 0x02B8, 0x0A90, 0x02B8, 0x0000,
185 0x0230, 0x0A90, 0x0350, 0x3FF0,
186 0x01B8, 0x0A78, 0x03F0, 0x3FE0,
187 0x0148, 0x0A48, 0x049C, 0x3FD4,
188 0x00E8, 0x0A00, 0x054C, 0x3FCC,
189 0x0098, 0x09A0, 0x0600, 0x3FC8,
190 0x0054, 0x0928, 0x06B4, 0x3FD0,
191 0x001C, 0x08A4, 0x0760, 0x3FE0,
192 0x3FFC, 0x0804, 0x0804, 0x3FFC
193 };
194
195 //=========================================
196 // <num_taps> = 4
197 // <num_phases> = 16
198 // <scale_ratio> = 1.83332 (input/output)
199 // <sharpness> = 0
200 // <CoefType> = ModifiedLanczos
201 // <CoefQuant> = 1.10
202 // <CoefOut> = 1.12
203 //=========================================
204 static const uint16_t filter_4tap_16p_183[36] = {
205 0x03B0, 0x08A0, 0x03B0, 0x0000,
206 0x0348, 0x0898, 0x041C, 0x0004,
207 0x02DC, 0x0884, 0x0490, 0x0010,
208 0x0278, 0x0864, 0x0500, 0x0024,
209 0x021C, 0x0838, 0x0570, 0x003C,
210 0x01C8, 0x07FC, 0x05E0, 0x005C,
211 0x0178, 0x07B8, 0x064C, 0x0084,
212 0x0130, 0x076C, 0x06B0, 0x00B4,
213 0x00F0, 0x0714, 0x0710, 0x00EC
214 };
215
216 //=========================================
217 // <num_taps> = 2
218 // <num_phases> = 64
219 // <scale_ratio> = 0.833333 (input/output)
220 // <sharpness> = 0
221 // <CoefType> = ModifiedLanczos
222 // <CoefQuant> = s1.10
223 // <CoefOut> = s1.12
224 //=========================================
225 static const uint16_t filter_2tap_64p[66] = {
226 0x1000, 0x0000,
227 0x1000, 0x0000,
228 0x0FFC, 0x0004,
229 0x0FF8, 0x0008,
230 0x0FF0, 0x0010,
231 0x0FE4, 0x001C,
232 0x0FD8, 0x0028,
233 0x0FC4, 0x003C,
234 0x0FB0, 0x0050,
235 0x0F98, 0x0068,
236 0x0F7C, 0x0084,
237 0x0F58, 0x00A8,
238 0x0F34, 0x00CC,
239 0x0F08, 0x00F8,
240 0x0ED8, 0x0128,
241 0x0EA4, 0x015C,
242 0x0E68, 0x0198,
243 0x0E28, 0x01D8,
244 0x0DE4, 0x021C,
245 0x0D98, 0x0268,
246 0x0D44, 0x02BC,
247 0x0CEC, 0x0314,
248 0x0C90, 0x0370,
249 0x0C2C, 0x03D4,
250 0x0BC4, 0x043C,
251 0x0B58, 0x04A8,
252 0x0AE8, 0x0518,
253 0x0A74, 0x058C,
254 0x09FC, 0x0604,
255 0x0980, 0x0680,
256 0x0900, 0x0700,
257 0x0880, 0x0780,
258 0x0800, 0x0800
259 };
260
261 //=========================================
262 // <num_taps> = 3
263 // <num_phases> = 64
264 // <scale_ratio> = 0.83333 (input/output)
265 // <sharpness> = 0
266 // <CoefType> = ModifiedLanczos
267 // <CoefQuant> = 1.10
268 // <CoefOut> = 1.12
269 //=========================================
270 static const uint16_t filter_3tap_64p_upscale[99] = {
271 0x0804, 0x07FC, 0x0000,
272 0x07A8, 0x0860, 0x3FF8,
273 0x0754, 0x08BC, 0x3FF0,
274 0x0700, 0x0918, 0x3FE8,
275 0x06AC, 0x0978, 0x3FDC,
276 0x0654, 0x09D8, 0x3FD4,
277 0x0604, 0x0A34, 0x3FC8,
278 0x05B0, 0x0A90, 0x3FC0,
279 0x055C, 0x0AF0, 0x3FB4,
280 0x050C, 0x0B48, 0x3FAC,
281 0x04BC, 0x0BA0, 0x3FA4,
282 0x0470, 0x0BF4, 0x3F9C,
283 0x0420, 0x0C50, 0x3F90,
284 0x03D8, 0x0C9C, 0x3F8C,
285 0x038C, 0x0CF0, 0x3F84,
286 0x0344, 0x0D40, 0x3F7C,
287 0x0300, 0x0D88, 0x3F78,
288 0x02BC, 0x0DD0, 0x3F74,
289 0x027C, 0x0E14, 0x3F70,
290 0x023C, 0x0E54, 0x3F70,
291 0x0200, 0x0E90, 0x3F70,
292 0x01C8, 0x0EC8, 0x3F70,
293 0x0190, 0x0EFC, 0x3F74,
294 0x015C, 0x0F2C, 0x3F78,
295 0x0128, 0x0F5C, 0x3F7C,
296 0x00FC, 0x0F7C, 0x3F88,
297 0x00CC, 0x0FA4, 0x3F90,
298 0x00A4, 0x0FC0, 0x3F9C,
299 0x007C, 0x0FD8, 0x3FAC,
300 0x0058, 0x0FE8, 0x3FC0,
301 0x0038, 0x0FF4, 0x3FD4,
302 0x0018, 0x1000, 0x3FE8,
303 0x0000, 0x1000, 0x0000
304 };
305
306 //=========================================
307 // <num_taps> = 3
308 // <num_phases> = 64
309 // <scale_ratio> = 1.16666 (input/output)
310 // <sharpness> = 0
311 // <CoefType> = ModifiedLanczos
312 // <CoefQuant> = 1.10
313 // <CoefOut> = 1.12
314 //=========================================
315 static const uint16_t filter_3tap_64p_116[99] = {
316 0x0804, 0x07FC, 0x0000,
317 0x07C0, 0x0844, 0x3FFC,
318 0x0780, 0x0888, 0x3FF8,
319 0x0740, 0x08D0, 0x3FF0,
320 0x0700, 0x0914, 0x3FEC,
321 0x06C0, 0x0958, 0x3FE8,
322 0x0684, 0x0998, 0x3FE4,
323 0x0644, 0x09DC, 0x3FE0,
324 0x0604, 0x0A1C, 0x3FE0,
325 0x05C4, 0x0A5C, 0x3FE0,
326 0x0588, 0x0A9C, 0x3FDC,
327 0x0548, 0x0ADC, 0x3FDC,
328 0x050C, 0x0B14, 0x3FE0,
329 0x04CC, 0x0B54, 0x3FE0,
330 0x0490, 0x0B8C, 0x3FE4,
331 0x0458, 0x0BC0, 0x3FE8,
332 0x041C, 0x0BF4, 0x3FF0,
333 0x03E0, 0x0C28, 0x3FF8,
334 0x03A8, 0x0C58, 0x0000,
335 0x0374, 0x0C88, 0x0004,
336 0x0340, 0x0CB0, 0x0010,
337 0x0308, 0x0CD8, 0x0020,
338 0x02D8, 0x0CFC, 0x002C,
339 0x02A0, 0x0D20, 0x0040,
340 0x0274, 0x0D3C, 0x0050,
341 0x0244, 0x0D58, 0x0064,
342 0x0214, 0x0D70, 0x007C,
343 0x01E8, 0x0D84, 0x0094,
344 0x01C0, 0x0D94, 0x00AC,
345 0x0198, 0x0DA0, 0x00C8,
346 0x0170, 0x0DAC, 0x00E4,
347 0x014C, 0x0DB0, 0x0104,
348 0x0128, 0x0DB4, 0x0124
349 };
350
351 //=========================================
352 // <num_taps> = 3
353 // <num_phases> = 64
354 // <scale_ratio> = 1.49999 (input/output)
355 // <sharpness> = 0
356 // <CoefType> = ModifiedLanczos
357 // <CoefQuant> = 1.10
358 // <CoefOut> = 1.12
359 //=========================================
360 static const uint16_t filter_3tap_64p_149[99] = {
361 0x0804, 0x07FC, 0x0000,
362 0x07CC, 0x0834, 0x0000,
363 0x0798, 0x0868, 0x0000,
364 0x0764, 0x089C, 0x0000,
365 0x0730, 0x08CC, 0x0004,
366 0x0700, 0x08FC, 0x0004,
367 0x06CC, 0x092C, 0x0008,
368 0x0698, 0x095C, 0x000C,
369 0x0660, 0x098C, 0x0014,
370 0x062C, 0x09B8, 0x001C,
371 0x05FC, 0x09E4, 0x0020,
372 0x05C4, 0x0A10, 0x002C,
373 0x0590, 0x0A3C, 0x0034,
374 0x055C, 0x0A64, 0x0040,
375 0x0528, 0x0A8C, 0x004C,
376 0x04F8, 0x0AB0, 0x0058,
377 0x04C4, 0x0AD4, 0x0068,
378 0x0490, 0x0AF8, 0x0078,
379 0x0460, 0x0B18, 0x0088,
380 0x0430, 0x0B38, 0x0098,
381 0x0400, 0x0B54, 0x00AC,
382 0x03D0, 0x0B6C, 0x00C4,
383 0x03A0, 0x0B88, 0x00D8,
384 0x0374, 0x0B9C, 0x00F0,
385 0x0348, 0x0BB0, 0x0108,
386 0x0318, 0x0BC4, 0x0124,
387 0x02EC, 0x0BD4, 0x0140,
388 0x02C4, 0x0BE0, 0x015C,
389 0x029C, 0x0BEC, 0x0178,
390 0x0274, 0x0BF4, 0x0198,
391 0x024C, 0x0BFC, 0x01B8,
392 0x0228, 0x0BFC, 0x01DC,
393 0x0200, 0x0C00, 0x0200
394 };
395
396 //=========================================
397 // <num_taps> = 3
398 // <num_phases> = 64
399 // <scale_ratio> = 1.83332 (input/output)
400 // <sharpness> = 0
401 // <CoefType> = ModifiedLanczos
402 // <CoefQuant> = 1.10
403 // <CoefOut> = 1.12
404 //=========================================
405 static const uint16_t filter_3tap_64p_183[99] = {
406 0x0804, 0x07FC, 0x0000,
407 0x07D4, 0x0824, 0x0008,
408 0x07AC, 0x0840, 0x0014,
409 0x0780, 0x0860, 0x0020,
410 0x0754, 0x0880, 0x002C,
411 0x0728, 0x089C, 0x003C,
412 0x0700, 0x08B8, 0x0048,
413 0x06D4, 0x08D4, 0x0058,
414 0x06A8, 0x08F0, 0x0068,
415 0x067C, 0x090C, 0x0078,
416 0x0650, 0x0924, 0x008C,
417 0x0628, 0x093C, 0x009C,
418 0x05FC, 0x0954, 0x00B0,
419 0x05D0, 0x096C, 0x00C4,
420 0x05A8, 0x0980, 0x00D8,
421 0x0578, 0x0998, 0x00F0,
422 0x0550, 0x09AC, 0x0104,
423 0x0528, 0x09BC, 0x011C,
424 0x04FC, 0x09D0, 0x0134,
425 0x04D4, 0x09E0, 0x014C,
426 0x04A8, 0x09F0, 0x0168,
427 0x0480, 0x09FC, 0x0184,
428 0x045C, 0x0A08, 0x019C,
429 0x0434, 0x0A14, 0x01B8,
430 0x0408, 0x0A20, 0x01D8,
431 0x03E0, 0x0A2C, 0x01F4,
432 0x03B8, 0x0A34, 0x0214,
433 0x0394, 0x0A38, 0x0234,
434 0x036C, 0x0A40, 0x0254,
435 0x0348, 0x0A44, 0x0274,
436 0x0324, 0x0A48, 0x0294,
437 0x0300, 0x0A48, 0x02B8,
438 0x02DC, 0x0A48, 0x02DC
439 };
440
441 //=========================================
442 // <num_taps> = 4
443 // <num_phases> = 64
444 // <scale_ratio> = 0.83333 (input/output)
445 // <sharpness> = 0
446 // <CoefType> = ModifiedLanczos
447 // <CoefQuant> = 1.10
448 // <CoefOut> = 1.12
449 //=========================================
450 static const uint16_t filter_4tap_64p_upscale[132] = {
451 0x0000, 0x1000, 0x0000, 0x0000,
452 0x3FDC, 0x0FFC, 0x0028, 0x0000,
453 0x3FB4, 0x0FF8, 0x0054, 0x0000,
454 0x3F94, 0x0FE8, 0x0084, 0x0000,
455 0x3F74, 0x0FDC, 0x00B4, 0x3FFC,
456 0x3F58, 0x0FC4, 0x00E8, 0x3FFC,
457 0x3F3C, 0x0FAC, 0x0120, 0x3FF8,
458 0x3F24, 0x0F90, 0x0158, 0x3FF4,
459 0x3F0C, 0x0F70, 0x0194, 0x3FF0,
460 0x3EF8, 0x0F4C, 0x01D0, 0x3FEC,
461 0x3EE8, 0x0F20, 0x0210, 0x3FE8,
462 0x3ED8, 0x0EF4, 0x0254, 0x3FE0,
463 0x3ECC, 0x0EC4, 0x0298, 0x3FD8,
464 0x3EC0, 0x0E90, 0x02DC, 0x3FD4,
465 0x3EB8, 0x0E58, 0x0324, 0x3FCC,
466 0x3EB0, 0x0E20, 0x036C, 0x3FC4,
467 0x3EAC, 0x0DE4, 0x03B8, 0x3FB8,
468 0x3EA8, 0x0DA4, 0x0404, 0x3FB0,
469 0x3EA4, 0x0D60, 0x0454, 0x3FA8,
470 0x3EA4, 0x0D1C, 0x04A4, 0x3F9C,
471 0x3EA4, 0x0CD8, 0x04F4, 0x3F90,
472 0x3EA8, 0x0C88, 0x0548, 0x3F88,
473 0x3EAC, 0x0C3C, 0x059C, 0x3F7C,
474 0x3EB0, 0x0BF0, 0x05F0, 0x3F70,
475 0x3EB8, 0x0BA0, 0x0644, 0x3F64,
476 0x3EBC, 0x0B54, 0x0698, 0x3F58,
477 0x3EC4, 0x0B00, 0x06F0, 0x3F4C,
478 0x3ECC, 0x0AAC, 0x0748, 0x3F40,
479 0x3ED8, 0x0A54, 0x07A0, 0x3F34,
480 0x3EE0, 0x0A04, 0x07F8, 0x3F24,
481 0x3EEC, 0x09AC, 0x0850, 0x3F18,
482 0x3EF8, 0x0954, 0x08A8, 0x3F0C,
483 0x3F00, 0x08FC, 0x0900, 0x3F04
484 };
485
486 //=========================================
487 // <num_taps> = 4
488 // <num_phases> = 64
489 // <scale_ratio> = 1.16666 (input/output)
490 // <sharpness> = 0
491 // <CoefType> = ModifiedLanczos
492 // <CoefQuant> = 1.10
493 // <CoefOut> = 1.12
494 //=========================================
495 static const uint16_t filter_4tap_64p_116[132] = {
496 0x01A8, 0x0CB4, 0x01A4, 0x0000,
497 0x017C, 0x0CB8, 0x01D0, 0x3FFC,
498 0x0158, 0x0CB8, 0x01F8, 0x3FF8,
499 0x0130, 0x0CB4, 0x0228, 0x3FF4,
500 0x0110, 0x0CB0, 0x0254, 0x3FEC,
501 0x00EC, 0x0CA8, 0x0284, 0x3FE8,
502 0x00CC, 0x0C9C, 0x02B4, 0x3FE4,
503 0x00AC, 0x0C90, 0x02E8, 0x3FDC,
504 0x0090, 0x0C80, 0x031C, 0x3FD4,
505 0x0070, 0x0C70, 0x0350, 0x3FD0,
506 0x0058, 0x0C5C, 0x0384, 0x3FC8,
507 0x003C, 0x0C48, 0x03BC, 0x3FC0,
508 0x0024, 0x0C2C, 0x03F4, 0x3FBC,
509 0x0010, 0x0C10, 0x042C, 0x3FB4,
510 0x3FFC, 0x0BF4, 0x0464, 0x3FAC,
511 0x3FE8, 0x0BD4, 0x04A0, 0x3FA4,
512 0x3FD8, 0x0BAC, 0x04DC, 0x3FA0,
513 0x3FC4, 0x0B8C, 0x0518, 0x3F98,
514 0x3FB4, 0x0B68, 0x0554, 0x3F90,
515 0x3FA8, 0x0B40, 0x0590, 0x3F88,
516 0x3F9C, 0x0B14, 0x05CC, 0x3F84,
517 0x3F90, 0x0AEC, 0x0608, 0x3F7C,
518 0x3F84, 0x0ABC, 0x0648, 0x3F78,
519 0x3F7C, 0x0A90, 0x0684, 0x3F70,
520 0x3F70, 0x0A60, 0x06C4, 0x3F6C,
521 0x3F6C, 0x0A2C, 0x0700, 0x3F68,
522 0x3F64, 0x09F8, 0x0740, 0x3F64,
523 0x3F60, 0x09C4, 0x077C, 0x3F60,
524 0x3F5C, 0x098C, 0x07BC, 0x3F5C,
525 0x3F58, 0x0958, 0x07F8, 0x3F58,
526 0x3F58, 0x091C, 0x0834, 0x3F58,
527 0x3F54, 0x08E4, 0x0870, 0x3F58,
528 0x3F54, 0x08AC, 0x08AC, 0x3F54
529 };
530
531 //=========================================
532 // <num_taps> = 4
533 // <num_phases> = 64
534 // <scale_ratio> = 1.49999 (input/output)
535 // <sharpness> = 0
536 // <CoefType> = ModifiedLanczos
537 // <CoefQuant> = 1.10
538 // <CoefOut> = 1.12
539 //=========================================
540 static const uint16_t filter_4tap_64p_149[132] = {
541 0x02B8, 0x0A90, 0x02B8, 0x0000,
542 0x0294, 0x0A94, 0x02DC, 0x3FFC,
543 0x0274, 0x0A94, 0x0300, 0x3FF8,
544 0x0250, 0x0A94, 0x0328, 0x3FF4,
545 0x0230, 0x0A90, 0x0350, 0x3FF0,
546 0x0214, 0x0A8C, 0x0374, 0x3FEC,
547 0x01F0, 0x0A88, 0x03A0, 0x3FE8,
548 0x01D4, 0x0A80, 0x03C8, 0x3FE4,
549 0x01B8, 0x0A78, 0x03F0, 0x3FE0,
550 0x0198, 0x0A70, 0x041C, 0x3FDC,
551 0x0180, 0x0A64, 0x0444, 0x3FD8,
552 0x0164, 0x0A54, 0x0470, 0x3FD8,
553 0x0148, 0x0A48, 0x049C, 0x3FD4,
554 0x0130, 0x0A38, 0x04C8, 0x3FD0,
555 0x0118, 0x0A24, 0x04F4, 0x3FD0,
556 0x0100, 0x0A14, 0x0520, 0x3FCC,
557 0x00E8, 0x0A00, 0x054C, 0x3FCC,
558 0x00D4, 0x09E8, 0x057C, 0x3FC8,
559 0x00C0, 0x09D0, 0x05A8, 0x3FC8,
560 0x00AC, 0x09B8, 0x05D4, 0x3FC8,
561 0x0098, 0x09A0, 0x0600, 0x3FC8,
562 0x0084, 0x0984, 0x0630, 0x3FC8,
563 0x0074, 0x0964, 0x065C, 0x3FCC,
564 0x0064, 0x0948, 0x0688, 0x3FCC,
565 0x0054, 0x0928, 0x06B4, 0x3FD0,
566 0x0044, 0x0908, 0x06E0, 0x3FD4,
567 0x0038, 0x08E8, 0x070C, 0x3FD4,
568 0x002C, 0x08C4, 0x0738, 0x3FD8,
569 0x001C, 0x08A4, 0x0760, 0x3FE0,
570 0x0014, 0x087C, 0x078C, 0x3FE4,
571 0x0008, 0x0858, 0x07B4, 0x3FEC,
572 0x0000, 0x0830, 0x07DC, 0x3FF4,
573 0x3FFC, 0x0804, 0x0804, 0x3FFC
574 };
575
576 //=========================================
577 // <num_taps> = 4
578 // <num_phases> = 64
579 // <scale_ratio> = 1.83332 (input/output)
580 // <sharpness> = 0
581 // <CoefType> = ModifiedLanczos
582 // <CoefQuant> = 1.10
583 // <CoefOut> = 1.12
584 //=========================================
585 static const uint16_t filter_4tap_64p_183[132] = {
586 0x03B0, 0x08A0, 0x03B0, 0x0000,
587 0x0394, 0x08A0, 0x03CC, 0x0000,
588 0x037C, 0x089C, 0x03E8, 0x0000,
589 0x0360, 0x089C, 0x0400, 0x0004,
590 0x0348, 0x0898, 0x041C, 0x0004,
591 0x032C, 0x0894, 0x0438, 0x0008,
592 0x0310, 0x0890, 0x0454, 0x000C,
593 0x02F8, 0x0888, 0x0474, 0x000C,
594 0x02DC, 0x0884, 0x0490, 0x0010,
595 0x02C4, 0x087C, 0x04AC, 0x0014,
596 0x02AC, 0x0874, 0x04C8, 0x0018,
597 0x0290, 0x086C, 0x04E4, 0x0020,
598 0x0278, 0x0864, 0x0500, 0x0024,
599 0x0264, 0x0858, 0x051C, 0x0028,
600 0x024C, 0x084C, 0x0538, 0x0030,
601 0x0234, 0x0844, 0x0554, 0x0034,
602 0x021C, 0x0838, 0x0570, 0x003C,
603 0x0208, 0x0828, 0x058C, 0x0044,
604 0x01F0, 0x081C, 0x05A8, 0x004C,
605 0x01DC, 0x080C, 0x05C4, 0x0054,
606 0x01C8, 0x07FC, 0x05E0, 0x005C,
607 0x01B4, 0x07EC, 0x05FC, 0x0064,
608 0x019C, 0x07DC, 0x0618, 0x0070,
609 0x018C, 0x07CC, 0x0630, 0x0078,
610 0x0178, 0x07B8, 0x064C, 0x0084,
611 0x0164, 0x07A8, 0x0664, 0x0090,
612 0x0150, 0x0794, 0x0680, 0x009C,
613 0x0140, 0x0780, 0x0698, 0x00A8,
614 0x0130, 0x076C, 0x06B0, 0x00B4,
615 0x0120, 0x0758, 0x06C8, 0x00C0,
616 0x0110, 0x0740, 0x06E0, 0x00D0,
617 0x0100, 0x072C, 0x06F8, 0x00DC,
618 0x00F0, 0x0714, 0x0710, 0x00EC
619 };
620
621 //=========================================
622 // <num_taps> = 5
623 // <num_phases> = 64
624 // <scale_ratio> = 0.83333 (input/output)
625 // <sharpness> = 0
626 // <CoefType> = ModifiedLanczos
627 // <CoefQuant> = 1.10
628 // <CoefOut> = 1.12
629 //=========================================
630 static const uint16_t filter_5tap_64p_upscale[165] = {
631 0x3E40, 0x09C0, 0x09C0, 0x3E40, 0x0000,
632 0x3E50, 0x0964, 0x0A18, 0x3E34, 0x0000,
633 0x3E5C, 0x0908, 0x0A6C, 0x3E2C, 0x0004,
634 0x3E6C, 0x08AC, 0x0AC0, 0x3E20, 0x0008,
635 0x3E78, 0x0850, 0x0B14, 0x3E18, 0x000C,
636 0x3E88, 0x07F4, 0x0B60, 0x3E14, 0x0010,
637 0x3E98, 0x0798, 0x0BB0, 0x3E0C, 0x0014,
638 0x3EA8, 0x073C, 0x0C00, 0x3E08, 0x0014,
639 0x3EB8, 0x06E4, 0x0C48, 0x3E04, 0x0018,
640 0x3ECC, 0x0684, 0x0C90, 0x3E04, 0x001C,
641 0x3EDC, 0x062C, 0x0CD4, 0x3E04, 0x0020,
642 0x3EEC, 0x05D4, 0x0D1C, 0x3E04, 0x0020,
643 0x3EFC, 0x057C, 0x0D5C, 0x3E08, 0x0024,
644 0x3F0C, 0x0524, 0x0D98, 0x3E10, 0x0028,
645 0x3F20, 0x04CC, 0x0DD8, 0x3E14, 0x0028,
646 0x3F30, 0x0478, 0x0E14, 0x3E1C, 0x0028,
647 0x3F40, 0x0424, 0x0E48, 0x3E28, 0x002C,
648 0x3F50, 0x03D4, 0x0E7C, 0x3E34, 0x002C,
649 0x3F60, 0x0384, 0x0EAC, 0x3E44, 0x002C,
650 0x3F6C, 0x0338, 0x0EDC, 0x3E54, 0x002C,
651 0x3F7C, 0x02E8, 0x0F08, 0x3E68, 0x002C,
652 0x3F8C, 0x02A0, 0x0F2C, 0x3E7C, 0x002C,
653 0x3F98, 0x0258, 0x0F50, 0x3E94, 0x002C,
654 0x3FA4, 0x0210, 0x0F74, 0x3EB0, 0x0028,
655 0x3FB0, 0x01CC, 0x0F90, 0x3ECC, 0x0028,
656 0x3FC0, 0x018C, 0x0FA8, 0x3EE8, 0x0024,
657 0x3FC8, 0x014C, 0x0FC0, 0x3F0C, 0x0020,
658 0x3FD4, 0x0110, 0x0FD4, 0x3F2C, 0x001C,
659 0x3FE0, 0x00D4, 0x0FE0, 0x3F54, 0x0018,
660 0x3FE8, 0x009C, 0x0FF0, 0x3F7C, 0x0010,
661 0x3FF0, 0x0064, 0x0FFC, 0x3FA4, 0x000C,
662 0x3FFC, 0x0030, 0x0FFC, 0x3FD4, 0x0004,
663 0x0000, 0x0000, 0x1000, 0x0000, 0x0000
664 };
665
666 //=========================================
667 // <num_taps> = 5
668 // <num_phases> = 64
669 // <scale_ratio> = 1.16666 (input/output)
670 // <sharpness> = 0
671 // <CoefType> = ModifiedLanczos
672 // <CoefQuant> = 1.10
673 // <CoefOut> = 1.12
674 //=========================================
675 static const uint16_t filter_5tap_64p_116[165] = {
676 0x3EDC, 0x0924, 0x0924, 0x3EDC, 0x0000,
677 0x3ED8, 0x08EC, 0x095C, 0x3EE0, 0x0000,
678 0x3ED4, 0x08B0, 0x0994, 0x3EE8, 0x0000,
679 0x3ED0, 0x0878, 0x09C8, 0x3EF0, 0x0000,
680 0x3ED0, 0x083C, 0x09FC, 0x3EF8, 0x0000,
681 0x3ED0, 0x0800, 0x0A2C, 0x3F04, 0x0000,
682 0x3ED0, 0x07C4, 0x0A5C, 0x3F10, 0x0000,
683 0x3ED0, 0x0788, 0x0A8C, 0x3F1C, 0x0000,
684 0x3ED0, 0x074C, 0x0AC0, 0x3F28, 0x3FFC,
685 0x3ED4, 0x0710, 0x0AE8, 0x3F38, 0x3FFC,
686 0x3ED8, 0x06D0, 0x0B18, 0x3F48, 0x3FF8,
687 0x3EDC, 0x0694, 0x0B3C, 0x3F5C, 0x3FF8,
688 0x3EE0, 0x0658, 0x0B68, 0x3F6C, 0x3FF4,
689 0x3EE4, 0x061C, 0x0B90, 0x3F80, 0x3FF0,
690 0x3EEC, 0x05DC, 0x0BB4, 0x3F98, 0x3FEC,
691 0x3EF0, 0x05A0, 0x0BD8, 0x3FB0, 0x3FE8,
692 0x3EF8, 0x0564, 0x0BF8, 0x3FC8, 0x3FE4,
693 0x3EFC, 0x0528, 0x0C1C, 0x3FE0, 0x3FE0,
694 0x3F04, 0x04EC, 0x0C38, 0x3FFC, 0x3FDC,
695 0x3F0C, 0x04B4, 0x0C54, 0x0014, 0x3FD8,
696 0x3F14, 0x047C, 0x0C70, 0x0030, 0x3FD0,
697 0x3F1C, 0x0440, 0x0C88, 0x0050, 0x3FCC,
698 0x3F24, 0x0408, 0x0CA0, 0x0070, 0x3FC4,
699 0x3F2C, 0x03D0, 0x0CB0, 0x0094, 0x3FC0,
700 0x3F34, 0x0398, 0x0CC4, 0x00B8, 0x3FB8,
701 0x3F3C, 0x0364, 0x0CD4, 0x00DC, 0x3FB0,
702 0x3F48, 0x032C, 0x0CE0, 0x0100, 0x3FAC,
703 0x3F50, 0x02F8, 0x0CEC, 0x0128, 0x3FA4,
704 0x3F58, 0x02C4, 0x0CF8, 0x0150, 0x3F9C,
705 0x3F60, 0x0290, 0x0D00, 0x017C, 0x3F94,
706 0x3F68, 0x0260, 0x0D04, 0x01A8, 0x3F8C,
707 0x3F74, 0x0230, 0x0D04, 0x01D4, 0x3F84,
708 0x3F7C, 0x0200, 0x0D08, 0x0200, 0x3F7C
709 };
710
711 //=========================================
712 // <num_taps> = 5
713 // <num_phases> = 64
714 // <scale_ratio> = 1.49999 (input/output)
715 // <sharpness> = 0
716 // <CoefType> = ModifiedLanczos
717 // <CoefQuant> = 1.10
718 // <CoefOut> = 1.12
719 //=========================================
720 static const uint16_t filter_5tap_64p_149[165] = {
721 0x3FF4, 0x080C, 0x080C, 0x3FF4, 0x0000,
722 0x3FE8, 0x07E8, 0x0830, 0x0000, 0x0000,
723 0x3FDC, 0x07C8, 0x0850, 0x0010, 0x3FFC,
724 0x3FD0, 0x07A4, 0x0878, 0x001C, 0x3FF8,
725 0x3FC4, 0x0780, 0x0898, 0x0030, 0x3FF4,
726 0x3FB8, 0x075C, 0x08B8, 0x0040, 0x3FF4,
727 0x3FB0, 0x0738, 0x08D8, 0x0050, 0x3FF0,
728 0x3FA8, 0x0710, 0x08F8, 0x0064, 0x3FEC,
729 0x3FA0, 0x06EC, 0x0914, 0x0078, 0x3FE8,
730 0x3F98, 0x06C4, 0x0934, 0x008C, 0x3FE4,
731 0x3F90, 0x06A0, 0x094C, 0x00A4, 0x3FE0,
732 0x3F8C, 0x0678, 0x0968, 0x00B8, 0x3FDC,
733 0x3F84, 0x0650, 0x0984, 0x00D0, 0x3FD8,
734 0x3F80, 0x0628, 0x099C, 0x00E8, 0x3FD4,
735 0x3F7C, 0x0600, 0x09B8, 0x0100, 0x3FCC,
736 0x3F78, 0x05D8, 0x09D0, 0x0118, 0x3FC8,
737 0x3F74, 0x05B0, 0x09E4, 0x0134, 0x3FC4,
738 0x3F70, 0x0588, 0x09F8, 0x0150, 0x3FC0,
739 0x3F70, 0x0560, 0x0A08, 0x016C, 0x3FBC,
740 0x3F6C, 0x0538, 0x0A20, 0x0188, 0x3FB4,
741 0x3F6C, 0x0510, 0x0A30, 0x01A4, 0x3FB0,
742 0x3F6C, 0x04E8, 0x0A3C, 0x01C4, 0x3FAC,
743 0x3F6C, 0x04C0, 0x0A48, 0x01E4, 0x3FA8,
744 0x3F6C, 0x0498, 0x0A58, 0x0200, 0x3FA4,
745 0x3F6C, 0x0470, 0x0A60, 0x0224, 0x3FA0,
746 0x3F6C, 0x0448, 0x0A70, 0x0244, 0x3F98,
747 0x3F70, 0x0420, 0x0A78, 0x0264, 0x3F94,
748 0x3F70, 0x03F8, 0x0A80, 0x0288, 0x3F90,
749 0x3F74, 0x03D4, 0x0A84, 0x02A8, 0x3F8C,
750 0x3F74, 0x03AC, 0x0A8C, 0x02CC, 0x3F88,
751 0x3F78, 0x0384, 0x0A90, 0x02F0, 0x3F84,
752 0x3F7C, 0x0360, 0x0A90, 0x0314, 0x3F80,
753 0x3F7C, 0x033C, 0x0A90, 0x033C, 0x3F7C
754 };
755
756 //=========================================
757 // <num_taps> = 5
758 // <num_phases> = 64
759 // <scale_ratio> = 1.83332 (input/output)
760 // <sharpness> = 0
761 // <CoefType> = ModifiedLanczos
762 // <CoefQuant> = 1.10
763 // <CoefOut> = 1.12
764 //=========================================
765 static const uint16_t filter_5tap_64p_183[165] = {
766 0x0168, 0x069C, 0x0698, 0x0164, 0x0000,
767 0x0154, 0x068C, 0x06AC, 0x0174, 0x0000,
768 0x0144, 0x0674, 0x06C0, 0x0188, 0x0000,
769 0x0138, 0x0664, 0x06D0, 0x0198, 0x3FFC,
770 0x0128, 0x0654, 0x06E0, 0x01A8, 0x3FFC,
771 0x0118, 0x0640, 0x06F0, 0x01BC, 0x3FFC,
772 0x010C, 0x0630, 0x0700, 0x01CC, 0x3FF8,
773 0x00FC, 0x061C, 0x0710, 0x01E0, 0x3FF8,
774 0x00F0, 0x060C, 0x071C, 0x01F0, 0x3FF8,
775 0x00E4, 0x05F4, 0x072C, 0x0204, 0x3FF8,
776 0x00D8, 0x05E4, 0x0738, 0x0218, 0x3FF4,
777 0x00CC, 0x05D0, 0x0744, 0x022C, 0x3FF4,
778 0x00C0, 0x05B8, 0x0754, 0x0240, 0x3FF4,
779 0x00B4, 0x05A4, 0x0760, 0x0254, 0x3FF4,
780 0x00A8, 0x0590, 0x076C, 0x0268, 0x3FF4,
781 0x009C, 0x057C, 0x0778, 0x027C, 0x3FF4,
782 0x0094, 0x0564, 0x0780, 0x0294, 0x3FF4,
783 0x0088, 0x0550, 0x0788, 0x02A8, 0x3FF8,
784 0x0080, 0x0538, 0x0794, 0x02BC, 0x3FF8,
785 0x0074, 0x0524, 0x079C, 0x02D4, 0x3FF8,
786 0x006C, 0x0510, 0x07A4, 0x02E8, 0x3FF8,
787 0x0064, 0x04F4, 0x07AC, 0x0300, 0x3FFC,
788 0x005C, 0x04E4, 0x07B0, 0x0314, 0x3FFC,
789 0x0054, 0x04C8, 0x07B8, 0x032C, 0x0000,
790 0x004C, 0x04B4, 0x07C0, 0x0340, 0x0000,
791 0x0044, 0x04A0, 0x07C4, 0x0358, 0x0000,
792 0x003C, 0x0488, 0x07C8, 0x0370, 0x0004,
793 0x0038, 0x0470, 0x07CC, 0x0384, 0x0008,
794 0x0030, 0x045C, 0x07D0, 0x039C, 0x0008,
795 0x002C, 0x0444, 0x07D0, 0x03B4, 0x000C,
796 0x0024, 0x042C, 0x07D4, 0x03CC, 0x0010,
797 0x0020, 0x0414, 0x07D4, 0x03E0, 0x0018,
798 0x001C, 0x03FC, 0x07D4, 0x03F8, 0x001C
799 };
800
801 //=========================================
802 // <num_taps> = 6
803 // <num_phases> = 64
804 // <scale_ratio> = 0.83333 (input/output)
805 // <sharpness> = 0
806 // <CoefType> = ModifiedLanczos
807 // <CoefQuant> = 1.10
808 // <CoefOut> = 1.12
809 //=========================================
810 static const uint16_t filter_6tap_64p_upscale[198] = {
811 0x0000, 0x0000, 0x1000, 0x0000, 0x0000, 0x0000,
812 0x000C, 0x3FD0, 0x0FFC, 0x0034, 0x3FF4, 0x0000,
813 0x0018, 0x3F9C, 0x0FF8, 0x006C, 0x3FE8, 0x0000,
814 0x0024, 0x3F6C, 0x0FF0, 0x00A8, 0x3FD8, 0x0000,
815 0x002C, 0x3F44, 0x0FE4, 0x00E4, 0x3FC8, 0x0000,
816 0x0038, 0x3F18, 0x0FD4, 0x0124, 0x3FB8, 0x0000,
817 0x0040, 0x3EF0, 0x0FC0, 0x0164, 0x3FA8, 0x0004,
818 0x0048, 0x3EC8, 0x0FAC, 0x01A8, 0x3F98, 0x0004,
819 0x0050, 0x3EA8, 0x0F94, 0x01EC, 0x3F84, 0x0004,
820 0x0058, 0x3E84, 0x0F74, 0x0234, 0x3F74, 0x0008,
821 0x0060, 0x3E68, 0x0F54, 0x027C, 0x3F60, 0x0008,
822 0x0064, 0x3E4C, 0x0F30, 0x02C8, 0x3F4C, 0x000C,
823 0x006C, 0x3E30, 0x0F04, 0x0314, 0x3F3C, 0x0010,
824 0x0070, 0x3E18, 0x0EDC, 0x0360, 0x3F28, 0x0014,
825 0x0074, 0x3E04, 0x0EB0, 0x03B0, 0x3F14, 0x0014,
826 0x0078, 0x3DF0, 0x0E80, 0x0400, 0x3F00, 0x0018,
827 0x0078, 0x3DE0, 0x0E4C, 0x0454, 0x3EEC, 0x001C,
828 0x007C, 0x3DD0, 0x0E14, 0x04A8, 0x3ED8, 0x0020,
829 0x007C, 0x3DC4, 0x0DDC, 0x04FC, 0x3EC4, 0x0024,
830 0x007C, 0x3DBC, 0x0DA0, 0x0550, 0x3EB0, 0x0028,
831 0x0080, 0x3DB4, 0x0D5C, 0x05A8, 0x3E9C, 0x002C,
832 0x0080, 0x3DAC, 0x0D1C, 0x0600, 0x3E88, 0x0030,
833 0x007C, 0x3DA8, 0x0CDC, 0x0658, 0x3E74, 0x0034,
834 0x007C, 0x3DA4, 0x0C94, 0x06B0, 0x3E64, 0x0038,
835 0x007C, 0x3DA4, 0x0C48, 0x0708, 0x3E50, 0x0040,
836 0x0078, 0x3DA4, 0x0C00, 0x0760, 0x3E40, 0x0044,
837 0x0078, 0x3DA8, 0x0BB4, 0x07B8, 0x3E2C, 0x0048,
838 0x0074, 0x3DAC, 0x0B68, 0x0810, 0x3E1C, 0x004C,
839 0x0070, 0x3DB4, 0x0B18, 0x0868, 0x3E0C, 0x0050,
840 0x006C, 0x3DBC, 0x0AC4, 0x08C4, 0x3DFC, 0x0054,
841 0x0068, 0x3DC4, 0x0A74, 0x0918, 0x3DF0, 0x0058,
842 0x0068, 0x3DCC, 0x0A20, 0x0970, 0x3DE0, 0x005C,
843 0x0064, 0x3DD4, 0x09C8, 0x09C8, 0x3DD4, 0x0064
844 };
845
846 //=========================================
847 // <num_taps> = 6
848 // <num_phases> = 64
849 // <scale_ratio> = 1.16666 (input/output)
850 // <sharpness> = 0
851 // <CoefType> = ModifiedLanczos
852 // <CoefQuant> = 1.10
853 // <CoefOut> = 1.12
854 //=========================================
855 static const uint16_t filter_6tap_64p_116[198] = {
856 0x3F0C, 0x0240, 0x0D68, 0x0240, 0x3F0C, 0x0000,
857 0x3F18, 0x0210, 0x0D64, 0x0274, 0x3F00, 0x0000,
858 0x3F24, 0x01E0, 0x0D58, 0x02A8, 0x3EF8, 0x0004,
859 0x3F2C, 0x01B0, 0x0D58, 0x02DC, 0x3EEC, 0x0004,
860 0x3F38, 0x0180, 0x0D50, 0x0310, 0x3EE0, 0x0008,
861 0x3F44, 0x0154, 0x0D40, 0x0348, 0x3ED8, 0x0008,
862 0x3F50, 0x0128, 0x0D34, 0x037C, 0x3ECC, 0x000C,
863 0x3F5C, 0x00FC, 0x0D20, 0x03B4, 0x3EC4, 0x0010,
864 0x3F64, 0x00D4, 0x0D14, 0x03EC, 0x3EB8, 0x0010,
865 0x3F70, 0x00AC, 0x0CFC, 0x0424, 0x3EB0, 0x0014,
866 0x3F78, 0x0084, 0x0CE8, 0x0460, 0x3EA8, 0x0014,
867 0x3F84, 0x0060, 0x0CCC, 0x0498, 0x3EA0, 0x0018,
868 0x3F90, 0x003C, 0x0CB4, 0x04D0, 0x3E98, 0x0018,
869 0x3F98, 0x0018, 0x0C9C, 0x050C, 0x3E90, 0x0018,
870 0x3FA0, 0x3FFC, 0x0C78, 0x0548, 0x3E88, 0x001C,
871 0x3FAC, 0x3FDC, 0x0C54, 0x0584, 0x3E84, 0x001C,
872 0x3FB4, 0x3FBC, 0x0C3C, 0x05BC, 0x3E7C, 0x001C,
873 0x3FBC, 0x3FA0, 0x0C14, 0x05F8, 0x3E78, 0x0020,
874 0x3FC4, 0x3F84, 0x0BF0, 0x0634, 0x3E74, 0x0020,
875 0x3FCC, 0x3F68, 0x0BCC, 0x0670, 0x3E70, 0x0020,
876 0x3FD4, 0x3F50, 0x0BA4, 0x06AC, 0x3E6C, 0x0020,
877 0x3FDC, 0x3F38, 0x0B78, 0x06E8, 0x3E6C, 0x0020,
878 0x3FE0, 0x3F24, 0x0B50, 0x0724, 0x3E68, 0x0020,
879 0x3FE8, 0x3F0C, 0x0B24, 0x0760, 0x3E68, 0x0020,
880 0x3FF0, 0x3EFC, 0x0AF4, 0x0798, 0x3E68, 0x0020,
881 0x3FF4, 0x3EE8, 0x0AC8, 0x07D4, 0x3E68, 0x0020,
882 0x3FFC, 0x3ED8, 0x0A94, 0x0810, 0x3E6C, 0x001C,
883 0x0000, 0x3EC8, 0x0A64, 0x0848, 0x3E70, 0x001C,
884 0x0000, 0x3EB8, 0x0A38, 0x0880, 0x3E74, 0x001C,
885 0x0004, 0x3EAC, 0x0A04, 0x08BC, 0x3E78, 0x0018,
886 0x0008, 0x3EA4, 0x09D0, 0x08F4, 0x3E7C, 0x0014,
887 0x000C, 0x3E98, 0x0998, 0x092C, 0x3E84, 0x0014,
888 0x0010, 0x3E90, 0x0964, 0x0960, 0x3E8C, 0x0010
889 };
890
891 //=========================================
892 // <num_taps> = 6
893 // <num_phases> = 64
894 // <scale_ratio> = 1.49999 (input/output)
895 // <sharpness> = 0
896 // <CoefType> = ModifiedLanczos
897 // <CoefQuant> = 1.10
898 // <CoefOut> = 1.12
899 //=========================================
900 static const uint16_t filter_6tap_64p_149[198] = {
901 0x3F14, 0x0394, 0x0AB0, 0x0394, 0x3F14, 0x0000,
902 0x3F18, 0x036C, 0x0AB0, 0x03B8, 0x3F14, 0x0000,
903 0x3F18, 0x0348, 0x0AAC, 0x03E0, 0x3F14, 0x0000,
904 0x3F1C, 0x0320, 0x0AAC, 0x0408, 0x3F10, 0x0000,
905 0x3F20, 0x02FC, 0x0AA8, 0x042C, 0x3F10, 0x0000,
906 0x3F24, 0x02D8, 0x0AA0, 0x0454, 0x3F10, 0x0000,
907 0x3F28, 0x02B4, 0x0A98, 0x047C, 0x3F10, 0x0000,
908 0x3F28, 0x0290, 0x0A90, 0x04A4, 0x3F14, 0x0000,
909 0x3F30, 0x026C, 0x0A84, 0x04CC, 0x3F14, 0x0000,
910 0x3F34, 0x024C, 0x0A7C, 0x04F4, 0x3F14, 0x3FFC,
911 0x3F38, 0x0228, 0x0A70, 0x051C, 0x3F18, 0x3FFC,
912 0x3F3C, 0x0208, 0x0A64, 0x0544, 0x3F1C, 0x3FF8,
913 0x3F40, 0x01E8, 0x0A54, 0x056C, 0x3F20, 0x3FF8,
914 0x3F44, 0x01C8, 0x0A48, 0x0594, 0x3F24, 0x3FF4,
915 0x3F4C, 0x01A8, 0x0A34, 0x05BC, 0x3F28, 0x3FF4,
916 0x3F50, 0x0188, 0x0A28, 0x05E4, 0x3F2C, 0x3FF0,
917 0x3F54, 0x016C, 0x0A10, 0x060C, 0x3F34, 0x3FF0,
918 0x3F5C, 0x014C, 0x09FC, 0x0634, 0x3F3C, 0x3FEC,
919 0x3F60, 0x0130, 0x09EC, 0x065C, 0x3F40, 0x3FE8,
920 0x3F68, 0x0114, 0x09D0, 0x0684, 0x3F48, 0x3FE8,
921 0x3F6C, 0x00F8, 0x09B8, 0x06AC, 0x3F54, 0x3FE4,
922 0x3F74, 0x00E0, 0x09A0, 0x06D0, 0x3F5C, 0x3FE0,
923 0x3F78, 0x00C4, 0x098C, 0x06F8, 0x3F64, 0x3FDC,
924 0x3F7C, 0x00AC, 0x0970, 0x0720, 0x3F70, 0x3FD8,
925 0x3F84, 0x0094, 0x0954, 0x0744, 0x3F7C, 0x3FD4,
926 0x3F88, 0x007C, 0x093C, 0x0768, 0x3F88, 0x3FD0,
927 0x3F90, 0x0064, 0x091C, 0x0790, 0x3F94, 0x3FCC,
928 0x3F94, 0x0050, 0x08FC, 0x07B4, 0x3FA4, 0x3FC8,
929 0x3F98, 0x003C, 0x08E0, 0x07D8, 0x3FB0, 0x3FC4,
930 0x3FA0, 0x0024, 0x08C0, 0x07FC, 0x3FC0, 0x3FC0,
931 0x3FA4, 0x0014, 0x08A4, 0x081C, 0x3FD0, 0x3FB8,
932 0x3FAC, 0x0000, 0x0880, 0x0840, 0x3FE0, 0x3FB4,
933 0x3FB0, 0x3FF0, 0x0860, 0x0860, 0x3FF0, 0x3FB0
934 };
935
936 //=========================================
937 // <num_taps> = 6
938 // <num_phases> = 64
939 // <scale_ratio> = 1.83332 (input/output)
940 // <sharpness> = 0
941 // <CoefType> = ModifiedLanczos
942 // <CoefQuant> = 1.10
943 // <CoefOut> = 1.12
944 //=========================================
945 static const uint16_t filter_6tap_64p_183[198] = {
946 0x002C, 0x0420, 0x076C, 0x041C, 0x002C, 0x0000,
947 0x0028, 0x040C, 0x0768, 0x0430, 0x0034, 0x0000,
948 0x0020, 0x03F8, 0x0768, 0x0448, 0x003C, 0x3FFC,
949 0x0018, 0x03E4, 0x0768, 0x045C, 0x0044, 0x3FFC,
950 0x0014, 0x03D0, 0x0768, 0x0470, 0x004C, 0x3FF8,
951 0x000C, 0x03BC, 0x0764, 0x0484, 0x0058, 0x3FF8,
952 0x0008, 0x03A4, 0x0764, 0x049C, 0x0060, 0x3FF4,
953 0x0004, 0x0390, 0x0760, 0x04B0, 0x0068, 0x3FF4,
954 0x0000, 0x037C, 0x0760, 0x04C4, 0x0070, 0x3FF0,
955 0x3FFC, 0x0364, 0x075C, 0x04D8, 0x007C, 0x3FF0,
956 0x3FF8, 0x0350, 0x0758, 0x04F0, 0x0084, 0x3FEC,
957 0x3FF4, 0x033C, 0x0750, 0x0504, 0x0090, 0x3FEC,
958 0x3FF0, 0x0328, 0x074C, 0x0518, 0x009C, 0x3FE8,
959 0x3FEC, 0x0314, 0x0744, 0x052C, 0x00A8, 0x3FE8,
960 0x3FE8, 0x0304, 0x0740, 0x0540, 0x00B0, 0x3FE4,
961 0x3FE4, 0x02EC, 0x073C, 0x0554, 0x00BC, 0x3FE4,
962 0x3FE0, 0x02DC, 0x0734, 0x0568, 0x00C8, 0x3FE0,
963 0x3FE0, 0x02C4, 0x072C, 0x057C, 0x00D4, 0x3FE0,
964 0x3FDC, 0x02B4, 0x0724, 0x058C, 0x00E4, 0x3FDC,
965 0x3FDC, 0x02A0, 0x0718, 0x05A0, 0x00F0, 0x3FDC,
966 0x3FD8, 0x028C, 0x0714, 0x05B4, 0x00FC, 0x3FD8,
967 0x3FD8, 0x0278, 0x0704, 0x05C8, 0x010C, 0x3FD8,
968 0x3FD4, 0x0264, 0x0700, 0x05D8, 0x0118, 0x3FD8,
969 0x3FD4, 0x0254, 0x06F0, 0x05EC, 0x0128, 0x3FD4,
970 0x3FD0, 0x0244, 0x06E8, 0x05FC, 0x0134, 0x3FD4,
971 0x3FD0, 0x0230, 0x06DC, 0x060C, 0x0144, 0x3FD4,
972 0x3FD0, 0x021C, 0x06D0, 0x0620, 0x0154, 0x3FD0,
973 0x3FD0, 0x0208, 0x06C4, 0x0630, 0x0164, 0x3FD0,
974 0x3FD0, 0x01F8, 0x06B8, 0x0640, 0x0170, 0x3FD0,
975 0x3FCC, 0x01E8, 0x06AC, 0x0650, 0x0180, 0x3FD0,
976 0x3FCC, 0x01D8, 0x069C, 0x0660, 0x0190, 0x3FD0,
977 0x3FCC, 0x01C4, 0x068C, 0x0670, 0x01A4, 0x3FD0,
978 0x3FCC, 0x01B8, 0x0680, 0x067C, 0x01B4, 0x3FCC
979 };
980
981 //=========================================
982 // <num_taps> = 7
983 // <num_phases> = 64
984 // <scale_ratio> = 0.83333 (input/output)
985 // <sharpness> = 0
986 // <CoefType> = ModifiedLanczos
987 // <CoefQuant> = 1.10
988 // <CoefOut> = 1.12
989 //=========================================
990 static const uint16_t filter_7tap_64p_upscale[231] = {
991 0x00B0, 0x3D98, 0x09BC, 0x09B8, 0x3D94, 0x00B0, 0x0000,
992 0x00AC, 0x3DA0, 0x0968, 0x0A10, 0x3D88, 0x00B4, 0x0000,
993 0x00A8, 0x3DAC, 0x0914, 0x0A60, 0x3D80, 0x00B8, 0x0000,
994 0x00A4, 0x3DB8, 0x08C0, 0x0AB4, 0x3D78, 0x00BC, 0x3FFC,
995 0x00A0, 0x3DC8, 0x0868, 0x0B00, 0x3D74, 0x00C0, 0x3FFC,
996 0x0098, 0x3DD8, 0x0818, 0x0B54, 0x3D6C, 0x00C0, 0x3FF8,
997 0x0094, 0x3DE8, 0x07C0, 0x0B9C, 0x3D6C, 0x00C4, 0x3FF8,
998 0x008C, 0x3DFC, 0x0768, 0x0BEC, 0x3D68, 0x00C4, 0x3FF8,
999 0x0088, 0x3E0C, 0x0714, 0x0C38, 0x3D68, 0x00C4, 0x3FF4,
1000 0x0080, 0x3E20, 0x06BC, 0x0C80, 0x3D6C, 0x00C4, 0x3FF4,
1001 0x0078, 0x3E34, 0x0668, 0x0CC4, 0x3D70, 0x00C4, 0x3FF4,
1002 0x0074, 0x3E48, 0x0610, 0x0D08, 0x3D78, 0x00C4, 0x3FF0,
1003 0x006C, 0x3E5C, 0x05BC, 0x0D48, 0x3D80, 0x00C4, 0x3FF0,
1004 0x0068, 0x3E74, 0x0568, 0x0D84, 0x3D88, 0x00C0, 0x3FF0,
1005 0x0060, 0x3E88, 0x0514, 0x0DC8, 0x3D94, 0x00BC, 0x3FEC,
1006 0x0058, 0x3E9C, 0x04C0, 0x0E04, 0x3DA4, 0x00B8, 0x3FEC,
1007 0x0054, 0x3EB4, 0x046C, 0x0E38, 0x3DB4, 0x00B4, 0x3FEC,
1008 0x004C, 0x3ECC, 0x0418, 0x0E6C, 0x3DC8, 0x00B0, 0x3FEC,
1009 0x0044, 0x3EE0, 0x03C8, 0x0EA4, 0x3DDC, 0x00A8, 0x3FEC,
1010 0x0040, 0x3EF8, 0x0378, 0x0ED0, 0x3DF4, 0x00A0, 0x3FEC,
1011 0x0038, 0x3F0C, 0x032C, 0x0EFC, 0x3E10, 0x0098, 0x3FEC,
1012 0x0034, 0x3F24, 0x02DC, 0x0F24, 0x3E2C, 0x0090, 0x3FEC,
1013 0x002C, 0x3F38, 0x0294, 0x0F4C, 0x3E48, 0x0088, 0x3FEC,
1014 0x0028, 0x3F50, 0x0248, 0x0F68, 0x3E6C, 0x007C, 0x3FF0,
1015 0x0020, 0x3F64, 0x0200, 0x0F88, 0x3E90, 0x0074, 0x3FF0,
1016 0x001C, 0x3F7C, 0x01B8, 0x0FA4, 0x3EB4, 0x0068, 0x3FF0,
1017 0x0018, 0x3F90, 0x0174, 0x0FBC, 0x3EDC, 0x0058, 0x3FF4,
1018 0x0014, 0x3FA4, 0x0130, 0x0FD0, 0x3F08, 0x004C, 0x3FF4,
1019 0x000C, 0x3FB8, 0x00F0, 0x0FE4, 0x3F34, 0x003C, 0x3FF8,
1020 0x0008, 0x3FCC, 0x00B0, 0x0FF0, 0x3F64, 0x0030, 0x3FF8,
1021 0x0004, 0x3FDC, 0x0070, 0x0FFC, 0x3F98, 0x0020, 0x3FFC,
1022 0x0000, 0x3FF0, 0x0038, 0x0FFC, 0x3FCC, 0x0010, 0x0000,
1023 0x0000, 0x0000, 0x0000, 0x1000, 0x0000, 0x0000, 0x0000
1024 };
1025
1026 //=========================================
1027 // <num_taps> = 7
1028 // <num_phases> = 64
1029 // <scale_ratio> = 1.16666 (input/output)
1030 // <sharpness> = 0
1031 // <CoefType> = ModifiedLanczos
1032 // <CoefQuant> = 1.10
1033 // <CoefOut> = 1.12
1034 //=========================================
1035 static const uint16_t filter_7tap_64p_116[231] = {
1036 0x0020, 0x3E58, 0x0988, 0x0988, 0x3E58, 0x0020, 0x0000,
1037 0x0024, 0x3E4C, 0x0954, 0x09C0, 0x3E64, 0x0018, 0x0000,
1038 0x002C, 0x3E44, 0x091C, 0x09F4, 0x3E70, 0x0010, 0x0000,
1039 0x0030, 0x3E3C, 0x08E8, 0x0A24, 0x3E80, 0x0008, 0x0000,
1040 0x0034, 0x3E34, 0x08AC, 0x0A5C, 0x3E90, 0x0000, 0x0000,
1041 0x003C, 0x3E30, 0x0870, 0x0A84, 0x3EA0, 0x3FFC, 0x0004,
1042 0x0040, 0x3E28, 0x0838, 0x0AB4, 0x3EB4, 0x3FF4, 0x0004,
1043 0x0044, 0x3E24, 0x07FC, 0x0AE4, 0x3EC8, 0x3FEC, 0x0004,
1044 0x0048, 0x3E24, 0x07C4, 0x0B08, 0x3EDC, 0x3FE4, 0x0008,
1045 0x0048, 0x3E20, 0x0788, 0x0B3C, 0x3EF4, 0x3FD8, 0x0008,
1046 0x004C, 0x3E20, 0x074C, 0x0B60, 0x3F0C, 0x3FD0, 0x000C,
1047 0x0050, 0x3E20, 0x0710, 0x0B8C, 0x3F24, 0x3FC4, 0x000C,
1048 0x0050, 0x3E20, 0x06D4, 0x0BB0, 0x3F40, 0x3FBC, 0x0010,
1049 0x0054, 0x3E24, 0x0698, 0x0BD4, 0x3F5C, 0x3FB0, 0x0010,
1050 0x0054, 0x3E24, 0x065C, 0x0BFC, 0x3F78, 0x3FA4, 0x0014,
1051 0x0054, 0x3E28, 0x0624, 0x0C1C, 0x3F98, 0x3F98, 0x0014,
1052 0x0058, 0x3E2C, 0x05E4, 0x0C3C, 0x3FB8, 0x3F8C, 0x0018,
1053 0x0058, 0x3E34, 0x05A8, 0x0C58, 0x3FD8, 0x3F80, 0x001C,
1054 0x0058, 0x3E38, 0x0570, 0x0C78, 0x3FF8, 0x3F74, 0x001C,
1055 0x0058, 0x3E40, 0x0534, 0x0C94, 0x0018, 0x3F68, 0x0020,
1056 0x0058, 0x3E48, 0x04F4, 0x0CAC, 0x0040, 0x3F5C, 0x0024,
1057 0x0058, 0x3E50, 0x04BC, 0x0CC4, 0x0064, 0x3F50, 0x0024,
1058 0x0054, 0x3E58, 0x0484, 0x0CD8, 0x008C, 0x3F44, 0x0028,
1059 0x0054, 0x3E60, 0x0448, 0x0CEC, 0x00B4, 0x3F38, 0x002C,
1060 0x0054, 0x3E68, 0x0410, 0x0CFC, 0x00E0, 0x3F28, 0x0030,
1061 0x0054, 0x3E74, 0x03D4, 0x0D0C, 0x010C, 0x3F1C, 0x0030,
1062 0x0050, 0x3E7C, 0x03A0, 0x0D18, 0x0138, 0x3F10, 0x0034,
1063 0x0050, 0x3E88, 0x0364, 0x0D24, 0x0164, 0x3F04, 0x0038,
1064 0x004C, 0x3E94, 0x0330, 0x0D30, 0x0194, 0x3EF4, 0x0038,
1065 0x004C, 0x3EA0, 0x02F8, 0x0D34, 0x01C4, 0x3EE8, 0x003C,
1066 0x0048, 0x3EAC, 0x02C0, 0x0D3C, 0x01F4, 0x3EDC, 0x0040,
1067 0x0048, 0x3EB8, 0x0290, 0x0D3C, 0x0224, 0x3ED0, 0x0040,
1068 0x0044, 0x3EC4, 0x0258, 0x0D40, 0x0258, 0x3EC4, 0x0044
1069 };
1070
1071 //=========================================
1072 // <num_taps> = 7
1073 // <num_phases> = 64
1074 // <scale_ratio> = 1.49999 (input/output)
1075 // <sharpness> = 0
1076 // <CoefType> = ModifiedLanczos
1077 // <CoefQuant> = 1.10
1078 // <CoefOut> = 1.12
1079 //=========================================
1080 static const uint16_t filter_7tap_64p_149[231] = {
1081 0x3F68, 0x3FEC, 0x08A8, 0x08AC, 0x3FF0, 0x3F68, 0x0000,
1082 0x3F70, 0x3FDC, 0x0888, 0x08CC, 0x0000, 0x3F60, 0x0000,
1083 0x3F74, 0x3FC8, 0x0868, 0x08F0, 0x0014, 0x3F58, 0x0000,
1084 0x3F7C, 0x3FB4, 0x0844, 0x0908, 0x002C, 0x3F54, 0x0004,
1085 0x3F84, 0x3FA4, 0x0820, 0x0924, 0x0044, 0x3F4C, 0x0004,
1086 0x3F88, 0x3F90, 0x0800, 0x0944, 0x005C, 0x3F44, 0x0004,
1087 0x3F90, 0x3F80, 0x07D8, 0x095C, 0x0074, 0x3F40, 0x0008,
1088 0x3F98, 0x3F70, 0x07B0, 0x097C, 0x008C, 0x3F38, 0x0008,
1089 0x3F9C, 0x3F60, 0x0790, 0x0994, 0x00A8, 0x3F30, 0x0008,
1090 0x3FA4, 0x3F54, 0x0764, 0x09B0, 0x00C4, 0x3F28, 0x0008,
1091 0x3FA8, 0x3F48, 0x0740, 0x09C4, 0x00DC, 0x3F24, 0x000C,
1092 0x3FB0, 0x3F38, 0x0718, 0x09DC, 0x00FC, 0x3F1C, 0x000C,
1093 0x3FB4, 0x3F2C, 0x06F0, 0x09F4, 0x0118, 0x3F18, 0x000C,
1094 0x3FBC, 0x3F24, 0x06C8, 0x0A08, 0x0134, 0x3F10, 0x000C,
1095 0x3FC0, 0x3F18, 0x06A0, 0x0A1C, 0x0154, 0x3F08, 0x0010,
1096 0x3FC8, 0x3F10, 0x0678, 0x0A2C, 0x0170, 0x3F04, 0x0010,
1097 0x3FCC, 0x3F04, 0x0650, 0x0A40, 0x0190, 0x3F00, 0x0010,
1098 0x3FD0, 0x3EFC, 0x0628, 0x0A54, 0x01B0, 0x3EF8, 0x0010,
1099 0x3FD4, 0x3EF4, 0x0600, 0x0A64, 0x01D0, 0x3EF4, 0x0010,
1100 0x3FDC, 0x3EEC, 0x05D8, 0x0A6C, 0x01F4, 0x3EF0, 0x0010,
1101 0x3FE0, 0x3EE8, 0x05B0, 0x0A7C, 0x0214, 0x3EE8, 0x0010,
1102 0x3FE4, 0x3EE0, 0x0588, 0x0A88, 0x0238, 0x3EE4, 0x0010,
1103 0x3FE8, 0x3EDC, 0x055C, 0x0A98, 0x0258, 0x3EE0, 0x0010,
1104 0x3FEC, 0x3ED8, 0x0534, 0x0AA0, 0x027C, 0x3EDC, 0x0010,
1105 0x3FF0, 0x3ED4, 0x050C, 0x0AAC, 0x02A0, 0x3ED8, 0x000C,
1106 0x3FF4, 0x3ED0, 0x04E4, 0x0AB4, 0x02C4, 0x3ED4, 0x000C,
1107 0x3FF4, 0x3ECC, 0x04C0, 0x0ABC, 0x02E8, 0x3ED0, 0x000C,
1108 0x3FF8, 0x3ECC, 0x0494, 0x0AC0, 0x030C, 0x3ED0, 0x000C,
1109 0x3FFC, 0x3EC8, 0x046C, 0x0AC8, 0x0334, 0x3ECC, 0x0008,
1110 0x0000, 0x3EC8, 0x0444, 0x0AC8, 0x0358, 0x3ECC, 0x0008,
1111 0x0000, 0x3EC8, 0x041C, 0x0ACC, 0x0380, 0x3EC8, 0x0008,
1112 0x0000, 0x3EC8, 0x03F4, 0x0AD0, 0x03A8, 0x3EC8, 0x0004,
1113 0x0004, 0x3EC8, 0x03CC, 0x0AD0, 0x03CC, 0x3EC8, 0x0004
1114 };
1115
1116 //=========================================
1117 // <num_taps> = 7
1118 // <num_phases> = 64
1119 // <scale_ratio> = 1.83332 (input/output)
1120 // <sharpness> = 0
1121 // <CoefType> = ModifiedLanczos
1122 // <CoefQuant> = 1.10
1123 // <CoefOut> = 1.12
1124 //=========================================
1125 static const uint16_t filter_7tap_64p_183[231] = {
1126 0x3FA4, 0x01E8, 0x0674, 0x0674, 0x01E8, 0x3FA4, 0x0000,
1127 0x3FA4, 0x01D4, 0x0668, 0x0684, 0x01F8, 0x3FA4, 0x0000,
1128 0x3FA4, 0x01C4, 0x0658, 0x0690, 0x0208, 0x3FA8, 0x0000,
1129 0x3FA0, 0x01B4, 0x064C, 0x06A0, 0x021C, 0x3FA8, 0x3FFC,
1130 0x3FA0, 0x01A4, 0x063C, 0x06AC, 0x022C, 0x3FAC, 0x3FFC,
1131 0x3FA0, 0x0194, 0x0630, 0x06B4, 0x0240, 0x3FAC, 0x3FFC,
1132 0x3FA0, 0x0184, 0x0620, 0x06C4, 0x0250, 0x3FB0, 0x3FF8,
1133 0x3FA0, 0x0174, 0x0614, 0x06CC, 0x0264, 0x3FB0, 0x3FF8,
1134 0x3FA0, 0x0164, 0x0604, 0x06D8, 0x0278, 0x3FB4, 0x3FF4,
1135 0x3FA0, 0x0154, 0x05F4, 0x06E4, 0x0288, 0x3FB8, 0x3FF4,
1136 0x3FA0, 0x0148, 0x05E4, 0x06EC, 0x029C, 0x3FBC, 0x3FF0,
1137 0x3FA0, 0x0138, 0x05D4, 0x06F4, 0x02B0, 0x3FC0, 0x3FF0,
1138 0x3FA0, 0x0128, 0x05C4, 0x0704, 0x02C4, 0x3FC0, 0x3FEC,
1139 0x3FA0, 0x011C, 0x05B4, 0x0708, 0x02D8, 0x3FC4, 0x3FEC,
1140 0x3FA4, 0x010C, 0x05A4, 0x0714, 0x02E8, 0x3FC8, 0x3FE8,
1141 0x3FA4, 0x0100, 0x0590, 0x0718, 0x02FC, 0x3FD0, 0x3FE8,
1142 0x3FA4, 0x00F0, 0x0580, 0x0724, 0x0310, 0x3FD4, 0x3FE4,
1143 0x3FA4, 0x00E4, 0x056C, 0x072C, 0x0324, 0x3FD8, 0x3FE4,
1144 0x3FA8, 0x00D8, 0x055C, 0x0730, 0x0338, 0x3FDC, 0x3FE0,
1145 0x3FA8, 0x00CC, 0x0548, 0x0738, 0x034C, 0x3FE4, 0x3FDC,
1146 0x3FA8, 0x00BC, 0x0538, 0x0740, 0x0360, 0x3FE8, 0x3FDC,
1147 0x3FAC, 0x00B0, 0x0528, 0x0744, 0x0374, 0x3FEC, 0x3FD8,
1148 0x3FAC, 0x00A4, 0x0514, 0x0748, 0x0388, 0x3FF4, 0x3FD8,
1149 0x3FB0, 0x0098, 0x0500, 0x074C, 0x039C, 0x3FFC, 0x3FD4,
1150 0x3FB0, 0x0090, 0x04EC, 0x0750, 0x03B0, 0x0000, 0x3FD4,
1151 0x3FB0, 0x0084, 0x04DC, 0x0758, 0x03C4, 0x0004, 0x3FD0,
1152 0x3FB4, 0x0078, 0x04CC, 0x0758, 0x03D8, 0x000C, 0x3FCC,
1153 0x3FB4, 0x006C, 0x04B8, 0x075C, 0x03EC, 0x0014, 0x3FCC,
1154 0x3FB8, 0x0064, 0x04A0, 0x0760, 0x0400, 0x001C, 0x3FC8,
1155 0x3FB8, 0x0058, 0x0490, 0x0760, 0x0414, 0x0024, 0x3FC8,
1156 0x3FBC, 0x0050, 0x047C, 0x0760, 0x0428, 0x002C, 0x3FC4,
1157 0x3FBC, 0x0048, 0x0464, 0x0764, 0x043C, 0x0034, 0x3FC4,
1158 0x3FC0, 0x003C, 0x0454, 0x0764, 0x0450, 0x003C, 0x3FC0
1159 };
1160
1161 //=========================================
1162 // <num_taps> = 8
1163 // <num_phases> = 64
1164 // <scale_ratio> = 0.83333 (input/output)
1165 // <sharpness> = 0
1166 // <CoefType> = ModifiedLanczos
1167 // <CoefQuant> = 1.10
1168 // <CoefOut> = 1.12
1169 //=========================================
1170 static const uint16_t filter_8tap_64p_upscale[264] = {
1171 0x0000, 0x0000, 0x0000, 0x1000, 0x0000, 0x0000, 0x0000, 0x0000,
1172 0x3FFC, 0x0014, 0x3FC8, 0x1000, 0x0038, 0x3FEC, 0x0004, 0x0000,
1173 0x3FF4, 0x0024, 0x3F94, 0x0FFC, 0x0074, 0x3FD8, 0x000C, 0x0000,
1174 0x3FF0, 0x0038, 0x3F60, 0x0FEC, 0x00B4, 0x3FC4, 0x0014, 0x0000,
1175 0x3FEC, 0x004C, 0x3F2C, 0x0FE4, 0x00F4, 0x3FAC, 0x0018, 0x0000,
1176 0x3FE4, 0x005C, 0x3F00, 0x0FD4, 0x0138, 0x3F94, 0x0020, 0x0000,
1177 0x3FE0, 0x006C, 0x3ED0, 0x0FC4, 0x017C, 0x3F7C, 0x0028, 0x0000,
1178 0x3FDC, 0x007C, 0x3EA8, 0x0FA4, 0x01C4, 0x3F68, 0x0030, 0x0000,
1179 0x3FD8, 0x0088, 0x3E80, 0x0F90, 0x020C, 0x3F50, 0x0038, 0x3FFC,
1180 0x3FD4, 0x0098, 0x3E58, 0x0F70, 0x0258, 0x3F38, 0x0040, 0x3FFC,
1181 0x3FD0, 0x00A4, 0x3E34, 0x0F54, 0x02A0, 0x3F1C, 0x004C, 0x3FFC,
1182 0x3FD0, 0x00B0, 0x3E14, 0x0F28, 0x02F0, 0x3F04, 0x0054, 0x3FFC,
1183 0x3FCC, 0x00BC, 0x3DF4, 0x0F08, 0x033C, 0x3EEC, 0x005C, 0x3FF8,
1184 0x3FC8, 0x00C8, 0x3DD8, 0x0EDC, 0x038C, 0x3ED4, 0x0064, 0x3FF8,
1185 0x3FC8, 0x00D0, 0x3DC0, 0x0EAC, 0x03E0, 0x3EBC, 0x006C, 0x3FF4,
1186 0x3FC4, 0x00D8, 0x3DA8, 0x0E7C, 0x0430, 0x3EA4, 0x0078, 0x3FF4,
1187 0x3FC4, 0x00E0, 0x3D94, 0x0E48, 0x0484, 0x3E8C, 0x0080, 0x3FF0,
1188 0x3FC4, 0x00E8, 0x3D80, 0x0E10, 0x04D8, 0x3E74, 0x0088, 0x3FF0,
1189 0x3FC4, 0x00F0, 0x3D70, 0x0DD8, 0x052C, 0x3E5C, 0x0090, 0x3FEC,
1190 0x3FC0, 0x00F4, 0x3D60, 0x0DA0, 0x0584, 0x3E44, 0x0098, 0x3FEC,
1191 0x3FC0, 0x00F8, 0x3D54, 0x0D68, 0x05D8, 0x3E2C, 0x00A0, 0x3FE8,
1192 0x3FC0, 0x00FC, 0x3D48, 0x0D20, 0x0630, 0x3E18, 0x00AC, 0x3FE8,
1193 0x3FC0, 0x0100, 0x3D40, 0x0CE0, 0x0688, 0x3E00, 0x00B4, 0x3FE4,
1194 0x3FC4, 0x0100, 0x3D3C, 0x0C98, 0x06DC, 0x3DEC, 0x00BC, 0x3FE4,
1195 0x3FC4, 0x0100, 0x3D38, 0x0C58, 0x0734, 0x3DD8, 0x00C0, 0x3FE0,
1196 0x3FC4, 0x0104, 0x3D38, 0x0C0C, 0x078C, 0x3DC4, 0x00C8, 0x3FDC,
1197 0x3FC4, 0x0100, 0x3D38, 0x0BC4, 0x07E4, 0x3DB0, 0x00D0, 0x3FDC,
1198 0x3FC4, 0x0100, 0x3D38, 0x0B78, 0x083C, 0x3DA0, 0x00D8, 0x3FD8,
1199 0x3FC8, 0x0100, 0x3D3C, 0x0B28, 0x0890, 0x3D90, 0x00DC, 0x3FD8,
1200 0x3FC8, 0x00FC, 0x3D40, 0x0ADC, 0x08E8, 0x3D80, 0x00E4, 0x3FD4,
1201 0x3FCC, 0x00FC, 0x3D48, 0x0A84, 0x093C, 0x3D74, 0x00E8, 0x3FD4,
1202 0x3FCC, 0x00F8, 0x3D50, 0x0A38, 0x0990, 0x3D64, 0x00F0, 0x3FD0,
1203 0x3FD0, 0x00F4, 0x3D58, 0x09E0, 0x09E4, 0x3D5C, 0x00F4, 0x3FD0
1204 };
1205
1206 //=========================================
1207 // <num_taps> = 8
1208 // <num_phases> = 64
1209 // <scale_ratio> = 1.16666 (input/output)
1210 // <sharpness> = 0
1211 // <CoefType> = ModifiedLanczos
1212 // <CoefQuant> = 1.10
1213 // <CoefOut> = 1.12
1214 //=========================================
1215 static const uint16_t filter_8tap_64p_116[264] = {
1216 0x0080, 0x3E90, 0x0268, 0x0D14, 0x0264, 0x3E90, 0x0080, 0x0000,
1217 0x007C, 0x3E9C, 0x0238, 0x0D14, 0x0298, 0x3E84, 0x0080, 0x0000,
1218 0x0078, 0x3EAC, 0x0200, 0x0D10, 0x02D0, 0x3E78, 0x0084, 0x0000,
1219 0x0078, 0x3EB8, 0x01D0, 0x0D0C, 0x0304, 0x3E6C, 0x0084, 0x0000,
1220 0x0074, 0x3EC8, 0x01A0, 0x0D00, 0x033C, 0x3E60, 0x0088, 0x0000,
1221 0x0070, 0x3ED4, 0x0170, 0x0D00, 0x0374, 0x3E54, 0x0088, 0x3FFC,
1222 0x006C, 0x3EE4, 0x0140, 0x0CF8, 0x03AC, 0x3E48, 0x0088, 0x3FFC,
1223 0x006C, 0x3EF0, 0x0114, 0x0CE8, 0x03E4, 0x3E3C, 0x008C, 0x3FFC,
1224 0x0068, 0x3F00, 0x00E8, 0x0CD8, 0x041C, 0x3E34, 0x008C, 0x3FFC,
1225 0x0064, 0x3F10, 0x00BC, 0x0CCC, 0x0454, 0x3E28, 0x008C, 0x3FFC,
1226 0x0060, 0x3F1C, 0x0090, 0x0CBC, 0x0490, 0x3E20, 0x008C, 0x3FFC,
1227 0x005C, 0x3F2C, 0x0068, 0x0CA4, 0x04CC, 0x3E18, 0x008C, 0x3FFC,
1228 0x0058, 0x3F38, 0x0040, 0x0C94, 0x0504, 0x3E10, 0x008C, 0x3FFC,
1229 0x0054, 0x3F48, 0x001C, 0x0C7C, 0x0540, 0x3E08, 0x0088, 0x3FFC,
1230 0x0050, 0x3F54, 0x3FF8, 0x0C60, 0x057C, 0x3E04, 0x0088, 0x3FFC,
1231 0x004C, 0x3F64, 0x3FD4, 0x0C44, 0x05B8, 0x3DFC, 0x0088, 0x3FFC,
1232 0x0048, 0x3F70, 0x3FB4, 0x0C28, 0x05F4, 0x3DF8, 0x0084, 0x3FFC,
1233 0x0044, 0x3F80, 0x3F90, 0x0C0C, 0x0630, 0x3DF4, 0x0080, 0x3FFC,
1234 0x0040, 0x3F8C, 0x3F70, 0x0BE8, 0x066C, 0x3DF4, 0x0080, 0x3FFC,
1235 0x003C, 0x3F9C, 0x3F50, 0x0BC8, 0x06A8, 0x3DF0, 0x007C, 0x3FFC,
1236 0x0038, 0x3FA8, 0x3F34, 0x0BA0, 0x06E4, 0x3DF0, 0x0078, 0x0000,
1237 0x0034, 0x3FB4, 0x3F18, 0x0B80, 0x071C, 0x3DF0, 0x0074, 0x0000,
1238 0x0030, 0x3FC0, 0x3EFC, 0x0B5C, 0x0758, 0x3DF0, 0x0070, 0x0000,
1239 0x002C, 0x3FCC, 0x3EE4, 0x0B34, 0x0794, 0x3DF4, 0x0068, 0x0000,
1240 0x002C, 0x3FDC, 0x3ECC, 0x0B08, 0x07CC, 0x3DF4, 0x0064, 0x0000,
1241 0x0028, 0x3FE4, 0x3EB4, 0x0AE0, 0x0808, 0x3DF8, 0x0060, 0x0000,
1242 0x0024, 0x3FF0, 0x3EA0, 0x0AB0, 0x0840, 0x3E00, 0x0058, 0x0004,
1243 0x0020, 0x3FFC, 0x3E90, 0x0A84, 0x0878, 0x3E04, 0x0050, 0x0004,
1244 0x001C, 0x0004, 0x3E7C, 0x0A54, 0x08B0, 0x3E0C, 0x004C, 0x0008,
1245 0x0018, 0x000C, 0x3E68, 0x0A28, 0x08E8, 0x3E18, 0x0044, 0x0008,
1246 0x0018, 0x0018, 0x3E54, 0x09F4, 0x0920, 0x3E20, 0x003C, 0x000C,
1247 0x0014, 0x0020, 0x3E48, 0x09C0, 0x0954, 0x3E2C, 0x0034, 0x0010,
1248 0x0010, 0x002C, 0x3E3C, 0x098C, 0x0988, 0x3E38, 0x002C, 0x0010
1249 };
1250
1251 //=========================================
1252 // <num_taps> = 8
1253 // <num_phases> = 64
1254 // <scale_ratio> = 1.49999 (input/output)
1255 // <sharpness> = 0
1256 // <CoefType> = ModifiedLanczos
1257 // <CoefQuant> = 1.10
1258 // <CoefOut> = 1.12
1259 //=========================================
1260 static const uint16_t filter_8tap_64p_149[264] = {
1261 0x0008, 0x3E8C, 0x03F8, 0x0AE8, 0x03F8, 0x3E8C, 0x0008, 0x0000,
1262 0x000C, 0x3E8C, 0x03D0, 0x0AE8, 0x0420, 0x3E90, 0x0000, 0x0000,
1263 0x000C, 0x3E8C, 0x03AC, 0x0AE8, 0x0444, 0x3E90, 0x0000, 0x0000,
1264 0x0010, 0x3E90, 0x0384, 0x0AE0, 0x046C, 0x3E94, 0x3FFC, 0x0000,
1265 0x0014, 0x3E90, 0x035C, 0x0ADC, 0x0494, 0x3E94, 0x3FF8, 0x0004,
1266 0x0018, 0x3E90, 0x0334, 0x0AD8, 0x04BC, 0x3E98, 0x3FF4, 0x0004,
1267 0x001C, 0x3E94, 0x0310, 0x0AD0, 0x04E4, 0x3E9C, 0x3FEC, 0x0004,
1268 0x0020, 0x3E98, 0x02E8, 0x0AC4, 0x050C, 0x3EA0, 0x3FE8, 0x0008,
1269 0x0020, 0x3E98, 0x02C4, 0x0AC0, 0x0534, 0x3EA4, 0x3FE4, 0x0008,
1270 0x0024, 0x3E9C, 0x02A0, 0x0AB4, 0x055C, 0x3EAC, 0x3FDC, 0x0008,
1271 0x0024, 0x3EA0, 0x027C, 0x0AA8, 0x0584, 0x3EB0, 0x3FD8, 0x000C,
1272 0x0028, 0x3EA4, 0x0258, 0x0A9C, 0x05AC, 0x3EB8, 0x3FD0, 0x000C,
1273 0x0028, 0x3EA8, 0x0234, 0x0A90, 0x05D4, 0x3EC0, 0x3FC8, 0x0010,
1274 0x002C, 0x3EAC, 0x0210, 0x0A80, 0x05FC, 0x3EC8, 0x3FC4, 0x0010,
1275 0x002C, 0x3EB4, 0x01F0, 0x0A70, 0x0624, 0x3ED0, 0x3FBC, 0x0010,
1276 0x002C, 0x3EB8, 0x01CC, 0x0A60, 0x064C, 0x3EDC, 0x3FB4, 0x0014,
1277 0x0030, 0x3EBC, 0x01A8, 0x0A50, 0x0674, 0x3EE4, 0x3FB0, 0x0014,
1278 0x0030, 0x3EC4, 0x0188, 0x0A38, 0x069C, 0x3EF0, 0x3FA8, 0x0018,
1279 0x0030, 0x3ECC, 0x0168, 0x0A28, 0x06C0, 0x3EFC, 0x3FA0, 0x0018,
1280 0x0030, 0x3ED0, 0x0148, 0x0A14, 0x06E8, 0x3F08, 0x3F98, 0x001C,
1281 0x0030, 0x3ED8, 0x012C, 0x0A00, 0x070C, 0x3F14, 0x3F90, 0x001C,
1282 0x0034, 0x3EE0, 0x0108, 0x09E4, 0x0734, 0x3F24, 0x3F8C, 0x001C,
1283 0x0034, 0x3EE4, 0x00EC, 0x09CC, 0x0758, 0x3F34, 0x3F84, 0x0020,
1284 0x0034, 0x3EEC, 0x00D0, 0x09B8, 0x077C, 0x3F40, 0x3F7C, 0x0020,
1285 0x0034, 0x3EF4, 0x00B4, 0x0998, 0x07A4, 0x3F50, 0x3F74, 0x0024,
1286 0x0030, 0x3EFC, 0x0098, 0x0980, 0x07C8, 0x3F64, 0x3F6C, 0x0024,
1287 0x0030, 0x3F04, 0x0080, 0x0968, 0x07E8, 0x3F74, 0x3F64, 0x0024,
1288 0x0030, 0x3F0C, 0x0060, 0x094C, 0x080C, 0x3F88, 0x3F5C, 0x0028,
1289 0x0030, 0x3F14, 0x0048, 0x0930, 0x0830, 0x3F98, 0x3F54, 0x0028,
1290 0x0030, 0x3F1C, 0x0030, 0x0914, 0x0850, 0x3FAC, 0x3F4C, 0x0028,
1291 0x0030, 0x3F24, 0x0018, 0x08F0, 0x0874, 0x3FC0, 0x3F44, 0x002C,
1292 0x002C, 0x3F2C, 0x0000, 0x08D4, 0x0894, 0x3FD8, 0x3F3C, 0x002C,
1293 0x002C, 0x3F34, 0x3FEC, 0x08B4, 0x08B4, 0x3FEC, 0x3F34, 0x002C
1294 };
1295
1296 //=========================================
1297 // <num_taps> = 8
1298 // <num_phases> = 64
1299 // <scale_ratio> = 1.83332 (input/output)
1300 // <sharpness> = 0
1301 // <CoefType> = ModifiedLanczos
1302 // <CoefQuant> = 1.10
1303 // <CoefOut> = 1.12
1304 //=========================================
1305 static const uint16_t filter_8tap_64p_183[264] = {
1306 0x3F88, 0x0048, 0x047C, 0x0768, 0x047C, 0x0048, 0x3F88, 0x0000,
1307 0x3F88, 0x003C, 0x0468, 0x076C, 0x0490, 0x0054, 0x3F84, 0x0000,
1308 0x3F8C, 0x0034, 0x0454, 0x0768, 0x04A4, 0x005C, 0x3F84, 0x0000,
1309 0x3F8C, 0x0028, 0x0444, 0x076C, 0x04B4, 0x0068, 0x3F80, 0x0000,
1310 0x3F90, 0x0020, 0x042C, 0x0768, 0x04C8, 0x0074, 0x3F80, 0x0000,
1311 0x3F90, 0x0018, 0x041C, 0x0764, 0x04DC, 0x0080, 0x3F7C, 0x0000,
1312 0x3F94, 0x0010, 0x0408, 0x075C, 0x04F0, 0x008C, 0x3F7C, 0x0000,
1313 0x3F94, 0x0004, 0x03F8, 0x0760, 0x0500, 0x0098, 0x3F7C, 0x3FFC,
1314 0x3F98, 0x0000, 0x03E0, 0x075C, 0x0514, 0x00A4, 0x3F78, 0x3FFC,
1315 0x3F9C, 0x3FF8, 0x03CC, 0x0754, 0x0528, 0x00B0, 0x3F78, 0x3FFC,
1316 0x3F9C, 0x3FF0, 0x03B8, 0x0754, 0x0538, 0x00BC, 0x3F78, 0x3FFC,
1317 0x3FA0, 0x3FE8, 0x03A4, 0x0750, 0x054C, 0x00CC, 0x3F74, 0x3FF8,
1318 0x3FA4, 0x3FE0, 0x0390, 0x074C, 0x055C, 0x00D8, 0x3F74, 0x3FF8,
1319 0x3FA4, 0x3FDC, 0x037C, 0x0744, 0x0570, 0x00E4, 0x3F74, 0x3FF8,
1320 0x3FA8, 0x3FD4, 0x0368, 0x0740, 0x0580, 0x00F4, 0x3F74, 0x3FF4,
1321 0x3FA8, 0x3FCC, 0x0354, 0x073C, 0x0590, 0x0104, 0x3F74, 0x3FF4,
1322 0x3FAC, 0x3FC8, 0x0340, 0x0730, 0x05A4, 0x0110, 0x3F74, 0x3FF4,
1323 0x3FB0, 0x3FC0, 0x0330, 0x0728, 0x05B4, 0x0120, 0x3F74, 0x3FF0,
1324 0x3FB0, 0x3FBC, 0x031C, 0x0724, 0x05C4, 0x0130, 0x3F70, 0x3FF0,
1325 0x3FB4, 0x3FB4, 0x0308, 0x0720, 0x05D4, 0x013C, 0x3F70, 0x3FF0,
1326 0x3FB8, 0x3FB0, 0x02F4, 0x0714, 0x05E4, 0x014C, 0x3F74, 0x3FEC,
1327 0x3FB8, 0x3FAC, 0x02E0, 0x0708, 0x05F8, 0x015C, 0x3F74, 0x3FEC,
1328 0x3FBC, 0x3FA8, 0x02CC, 0x0704, 0x0604, 0x016C, 0x3F74, 0x3FE8,
1329 0x3FC0, 0x3FA0, 0x02BC, 0x06F8, 0x0614, 0x017C, 0x3F74, 0x3FE8,
1330 0x3FC0, 0x3F9C, 0x02A8, 0x06F4, 0x0624, 0x018C, 0x3F74, 0x3FE4,
1331 0x3FC4, 0x3F98, 0x0294, 0x06E8, 0x0634, 0x019C, 0x3F74, 0x3FE4,
1332 0x3FC8, 0x3F94, 0x0284, 0x06D8, 0x0644, 0x01AC, 0x3F78, 0x3FE0,
1333 0x3FC8, 0x3F90, 0x0270, 0x06D4, 0x0650, 0x01BC, 0x3F78, 0x3FE0,
1334 0x3FCC, 0x3F8C, 0x025C, 0x06C8, 0x0660, 0x01D0, 0x3F78, 0x3FDC,
1335 0x3FCC, 0x3F8C, 0x024C, 0x06B8, 0x066C, 0x01E0, 0x3F7C, 0x3FDC,
1336 0x3FD0, 0x3F88, 0x0238, 0x06B0, 0x067C, 0x01F0, 0x3F7C, 0x3FD8,
1337 0x3FD4, 0x3F84, 0x0228, 0x069C, 0x0688, 0x0204, 0x3F80, 0x3FD8,
1338 0x3FD4, 0x3F84, 0x0214, 0x0694, 0x0694, 0x0214, 0x3F84, 0x3FD4
1339 };
1340
get_filter_3tap_16p(struct fixed31_32 ratio)1341 const uint16_t *get_filter_3tap_16p(struct fixed31_32 ratio)
1342 {
1343 if (ratio.value < dc_fixpt_one.value)
1344 return filter_3tap_16p_upscale;
1345 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1346 return filter_3tap_16p_116;
1347 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1348 return filter_3tap_16p_149;
1349 else
1350 return filter_3tap_16p_183;
1351 }
1352
get_filter_3tap_64p(struct fixed31_32 ratio)1353 const uint16_t *get_filter_3tap_64p(struct fixed31_32 ratio)
1354 {
1355 if (ratio.value < dc_fixpt_one.value)
1356 return filter_3tap_64p_upscale;
1357 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1358 return filter_3tap_64p_116;
1359 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1360 return filter_3tap_64p_149;
1361 else
1362 return filter_3tap_64p_183;
1363 }
1364
get_filter_4tap_16p(struct fixed31_32 ratio)1365 const uint16_t *get_filter_4tap_16p(struct fixed31_32 ratio)
1366 {
1367 if (ratio.value < dc_fixpt_one.value)
1368 return filter_4tap_16p_upscale;
1369 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1370 return filter_4tap_16p_116;
1371 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1372 return filter_4tap_16p_149;
1373 else
1374 return filter_4tap_16p_183;
1375 }
1376
get_filter_4tap_64p(struct fixed31_32 ratio)1377 const uint16_t *get_filter_4tap_64p(struct fixed31_32 ratio)
1378 {
1379 if (ratio.value < dc_fixpt_one.value)
1380 return filter_4tap_64p_upscale;
1381 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1382 return filter_4tap_64p_116;
1383 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1384 return filter_4tap_64p_149;
1385 else
1386 return filter_4tap_64p_183;
1387 }
1388
get_filter_5tap_64p(struct fixed31_32 ratio)1389 const uint16_t *get_filter_5tap_64p(struct fixed31_32 ratio)
1390 {
1391 if (ratio.value < dc_fixpt_one.value)
1392 return filter_5tap_64p_upscale;
1393 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1394 return filter_5tap_64p_116;
1395 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1396 return filter_5tap_64p_149;
1397 else
1398 return filter_5tap_64p_183;
1399 }
1400
get_filter_6tap_64p(struct fixed31_32 ratio)1401 const uint16_t *get_filter_6tap_64p(struct fixed31_32 ratio)
1402 {
1403 if (ratio.value < dc_fixpt_one.value)
1404 return filter_6tap_64p_upscale;
1405 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1406 return filter_6tap_64p_116;
1407 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1408 return filter_6tap_64p_149;
1409 else
1410 return filter_6tap_64p_183;
1411 }
1412
get_filter_7tap_64p(struct fixed31_32 ratio)1413 const uint16_t *get_filter_7tap_64p(struct fixed31_32 ratio)
1414 {
1415 if (ratio.value < dc_fixpt_one.value)
1416 return filter_7tap_64p_upscale;
1417 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1418 return filter_7tap_64p_116;
1419 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1420 return filter_7tap_64p_149;
1421 else
1422 return filter_7tap_64p_183;
1423 }
1424
get_filter_8tap_64p(struct fixed31_32 ratio)1425 const uint16_t *get_filter_8tap_64p(struct fixed31_32 ratio)
1426 {
1427 if (ratio.value < dc_fixpt_one.value)
1428 return filter_8tap_64p_upscale;
1429 else if (ratio.value < dc_fixpt_from_fraction(4, 3).value)
1430 return filter_8tap_64p_116;
1431 else if (ratio.value < dc_fixpt_from_fraction(5, 3).value)
1432 return filter_8tap_64p_149;
1433 else
1434 return filter_8tap_64p_183;
1435 }
1436
get_filter_2tap_16p(void)1437 const uint16_t *get_filter_2tap_16p(void)
1438 {
1439 return filter_2tap_16p;
1440 }
1441
get_filter_2tap_64p(void)1442 const uint16_t *get_filter_2tap_64p(void)
1443 {
1444 return filter_2tap_64p;
1445 }
1446