drivers/gpu/drm/amd/display/dc/dce/dce_scl_filters.c

   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
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
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
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
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
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
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
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
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
1437 const uint16_t *get_filter_2tap_16p(void)
1438 {
1439         return filter_2tap_16p;
1440 }
1441
1442 const uint16_t *get_filter_2tap_64p(void)
1443 {
1444         return filter_2tap_64p;
1445 }