1 // Copyright 2015 Google Inc. All Rights Reserved. 2 // 3 // Use of this source code is governed by a BSD-style license 4 // that can be found in the COPYING file in the root of the source 5 // tree. An additional intellectual property rights grant can be found 6 // in the file PATENTS. All contributing project authors may 7 // be found in the AUTHORS file in the root of the source tree. 8 // ----------------------------------------------------------------------------- 9 // 10 // Image transform methods for lossless encoder. 11 // 12 // Authors: Vikas Arora (vikaas.arora (at) gmail.com) 13 // Jyrki Alakuijala (jyrki (at) google.com) 14 // Urvang Joshi (urvang (at) google.com) 15 16 #include "src/dsp/dsp.h" 17 18 #include <assert.h> 19 #include <math.h> 20 #include <stdlib.h> 21 #include "src/dec/vp8li_dec.h" 22 #include "src/utils/endian_inl_utils.h" 23 #include "src/dsp/lossless.h" 24 #include "src/dsp/lossless_common.h" 25 #include "src/dsp/yuv.h" 26 27 // lookup table for small values of log2(int) 28 const float kLog2Table[LOG_LOOKUP_IDX_MAX] = { 29 0.0000000000000000f, 0.0000000000000000f, 30 1.0000000000000000f, 1.5849625007211560f, 31 2.0000000000000000f, 2.3219280948873621f, 32 2.5849625007211560f, 2.8073549220576041f, 33 3.0000000000000000f, 3.1699250014423121f, 34 3.3219280948873621f, 3.4594316186372973f, 35 3.5849625007211560f, 3.7004397181410921f, 36 3.8073549220576041f, 3.9068905956085187f, 37 4.0000000000000000f, 4.0874628412503390f, 38 4.1699250014423121f, 4.2479275134435852f, 39 4.3219280948873626f, 4.3923174227787606f, 40 4.4594316186372973f, 4.5235619560570130f, 41 4.5849625007211560f, 4.6438561897747243f, 42 4.7004397181410917f, 4.7548875021634682f, 43 4.8073549220576037f, 4.8579809951275718f, 44 4.9068905956085187f, 4.9541963103868749f, 45 5.0000000000000000f, 5.0443941193584533f, 46 5.0874628412503390f, 5.1292830169449663f, 47 5.1699250014423121f, 5.2094533656289501f, 48 5.2479275134435852f, 5.2854022188622487f, 49 5.3219280948873626f, 5.3575520046180837f, 50 5.3923174227787606f, 5.4262647547020979f, 51 5.4594316186372973f, 5.4918530963296747f, 52 5.5235619560570130f, 5.5545888516776376f, 53 5.5849625007211560f, 5.6147098441152083f, 54 5.6438561897747243f, 5.6724253419714951f, 55 5.7004397181410917f, 5.7279204545631987f, 56 5.7548875021634682f, 5.7813597135246599f, 57 5.8073549220576037f, 5.8328900141647412f, 58 5.8579809951275718f, 5.8826430493618415f, 59 5.9068905956085187f, 5.9307373375628866f, 60 5.9541963103868749f, 5.9772799234999167f, 61 6.0000000000000000f, 6.0223678130284543f, 62 6.0443941193584533f, 6.0660891904577720f, 63 6.0874628412503390f, 6.1085244567781691f, 64 6.1292830169449663f, 6.1497471195046822f, 65 6.1699250014423121f, 6.1898245588800175f, 66 6.2094533656289501f, 6.2288186904958804f, 67 6.2479275134435852f, 6.2667865406949010f, 68 6.2854022188622487f, 6.3037807481771030f, 69 6.3219280948873626f, 6.3398500028846243f, 70 6.3575520046180837f, 6.3750394313469245f, 71 6.3923174227787606f, 6.4093909361377017f, 72 6.4262647547020979f, 6.4429434958487279f, 73 6.4594316186372973f, 6.4757334309663976f, 74 6.4918530963296747f, 6.5077946401986963f, 75 6.5235619560570130f, 6.5391588111080309f, 76 6.5545888516776376f, 6.5698556083309478f, 77 6.5849625007211560f, 6.5999128421871278f, 78 6.6147098441152083f, 6.6293566200796094f, 79 6.6438561897747243f, 6.6582114827517946f, 80 6.6724253419714951f, 6.6865005271832185f, 81 6.7004397181410917f, 6.7142455176661224f, 82 6.7279204545631987f, 6.7414669864011464f, 83 6.7548875021634682f, 6.7681843247769259f, 84 6.7813597135246599f, 6.7944158663501061f, 85 6.8073549220576037f, 6.8201789624151878f, 86 6.8328900141647412f, 6.8454900509443747f, 87 6.8579809951275718f, 6.8703647195834047f, 88 6.8826430493618415f, 6.8948177633079437f, 89 6.9068905956085187f, 6.9188632372745946f, 90 6.9307373375628866f, 6.9425145053392398f, 91 6.9541963103868749f, 6.9657842846620869f, 92 6.9772799234999167f, 6.9886846867721654f, 93 7.0000000000000000f, 7.0112272554232539f, 94 7.0223678130284543f, 7.0334230015374501f, 95 7.0443941193584533f, 7.0552824355011898f, 96 7.0660891904577720f, 7.0768155970508308f, 97 7.0874628412503390f, 7.0980320829605263f, 98 7.1085244567781691f, 7.1189410727235076f, 99 7.1292830169449663f, 7.1395513523987936f, 100 7.1497471195046822f, 7.1598713367783890f, 101 7.1699250014423121f, 7.1799090900149344f, 102 7.1898245588800175f, 7.1996723448363644f, 103 7.2094533656289501f, 7.2191685204621611f, 104 7.2288186904958804f, 7.2384047393250785f, 105 7.2479275134435852f, 7.2573878426926521f, 106 7.2667865406949010f, 7.2761244052742375f, 107 7.2854022188622487f, 7.2946207488916270f, 108 7.3037807481771030f, 7.3128829552843557f, 109 7.3219280948873626f, 7.3309168781146167f, 110 7.3398500028846243f, 7.3487281542310771f, 111 7.3575520046180837f, 7.3663222142458160f, 112 7.3750394313469245f, 7.3837042924740519f, 113 7.3923174227787606f, 7.4008794362821843f, 114 7.4093909361377017f, 7.4178525148858982f, 115 7.4262647547020979f, 7.4346282276367245f, 116 7.4429434958487279f, 7.4512111118323289f, 117 7.4594316186372973f, 7.4676055500829976f, 118 7.4757334309663976f, 7.4838157772642563f, 119 7.4918530963296747f, 7.4998458870832056f, 120 7.5077946401986963f, 7.5156998382840427f, 121 7.5235619560570130f, 7.5313814605163118f, 122 7.5391588111080309f, 7.5468944598876364f, 123 7.5545888516776376f, 7.5622424242210728f, 124 7.5698556083309478f, 7.5774288280357486f, 125 7.5849625007211560f, 7.5924570372680806f, 126 7.5999128421871278f, 7.6073303137496104f, 127 7.6147098441152083f, 7.6220518194563764f, 128 7.6293566200796094f, 7.6366246205436487f, 129 7.6438561897747243f, 7.6510516911789281f, 130 7.6582114827517946f, 7.6653359171851764f, 131 7.6724253419714951f, 7.6794800995054464f, 132 7.6865005271832185f, 7.6934869574993252f, 133 7.7004397181410917f, 7.7073591320808825f, 134 7.7142455176661224f, 7.7210991887071855f, 135 7.7279204545631987f, 7.7347096202258383f, 136 7.7414669864011464f, 7.7481928495894605f, 137 7.7548875021634682f, 7.7615512324444795f, 138 7.7681843247769259f, 7.7747870596011736f, 139 7.7813597135246599f, 7.7879025593914317f, 140 7.7944158663501061f, 7.8008998999203047f, 141 7.8073549220576037f, 7.8137811912170374f, 142 7.8201789624151878f, 7.8265484872909150f, 143 7.8328900141647412f, 7.8392037880969436f, 144 7.8454900509443747f, 7.8517490414160571f, 145 7.8579809951275718f, 7.8641861446542797f, 146 7.8703647195834047f, 7.8765169465649993f, 147 7.8826430493618415f, 7.8887432488982591f, 148 7.8948177633079437f, 7.9008668079807486f, 149 7.9068905956085187f, 7.9128893362299619f, 150 7.9188632372745946f, 7.9248125036057812f, 151 7.9307373375628866f, 7.9366379390025709f, 152 7.9425145053392398f, 7.9483672315846778f, 153 7.9541963103868749f, 7.9600019320680805f, 154 7.9657842846620869f, 7.9715435539507719f, 155 7.9772799234999167f, 7.9829935746943103f, 156 7.9886846867721654f, 7.9943534368588577f 157 }; 158 159 const float kSLog2Table[LOG_LOOKUP_IDX_MAX] = { 160 0.00000000f, 0.00000000f, 2.00000000f, 4.75488750f, 161 8.00000000f, 11.60964047f, 15.50977500f, 19.65148445f, 162 24.00000000f, 28.52932501f, 33.21928095f, 38.05374781f, 163 43.01955001f, 48.10571634f, 53.30296891f, 58.60335893f, 164 64.00000000f, 69.48686830f, 75.05865003f, 80.71062276f, 165 86.43856190f, 92.23866588f, 98.10749561f, 104.04192499f, 166 110.03910002f, 116.09640474f, 122.21143267f, 128.38196256f, 167 134.60593782f, 140.88144886f, 147.20671787f, 153.58008562f, 168 160.00000000f, 166.46500594f, 172.97373660f, 179.52490559f, 169 186.11730005f, 192.74977453f, 199.42124551f, 206.13068654f, 170 212.87712380f, 219.65963219f, 226.47733176f, 233.32938445f, 171 240.21499122f, 247.13338933f, 254.08384998f, 261.06567603f, 172 268.07820003f, 275.12078236f, 282.19280949f, 289.29369244f, 173 296.42286534f, 303.57978409f, 310.76392512f, 317.97478424f, 174 325.21187564f, 332.47473081f, 339.76289772f, 347.07593991f, 175 354.41343574f, 361.77497759f, 369.16017124f, 376.56863518f, 176 384.00000000f, 391.45390785f, 398.93001188f, 406.42797576f, 177 413.94747321f, 421.48818752f, 429.04981119f, 436.63204548f, 178 444.23460010f, 451.85719280f, 459.49954906f, 467.16140179f, 179 474.84249102f, 482.54256363f, 490.26137307f, 497.99867911f, 180 505.75424759f, 513.52785023f, 521.31926438f, 529.12827280f, 181 536.95466351f, 544.79822957f, 552.65876890f, 560.53608414f, 182 568.42998244f, 576.34027536f, 584.26677867f, 592.20931226f, 183 600.16769996f, 608.14176943f, 616.13135206f, 624.13628279f, 184 632.15640007f, 640.19154569f, 648.24156472f, 656.30630539f, 185 664.38561898f, 672.47935976f, 680.58738488f, 688.70955430f, 186 696.84573069f, 704.99577935f, 713.15956818f, 721.33696754f, 187 729.52785023f, 737.73209140f, 745.94956849f, 754.18016116f, 188 762.42375127f, 770.68022275f, 778.94946161f, 787.23135586f, 189 795.52579543f, 803.83267219f, 812.15187982f, 820.48331383f, 190 828.82687147f, 837.18245171f, 845.54995518f, 853.92928416f, 191 862.32034249f, 870.72303558f, 879.13727036f, 887.56295522f, 192 896.00000000f, 904.44831595f, 912.90781569f, 921.37841320f, 193 929.86002376f, 938.35256392f, 946.85595152f, 955.37010560f, 194 963.89494641f, 972.43039537f, 980.97637504f, 989.53280911f, 195 998.09962237f, 1006.67674069f, 1015.26409097f, 1023.86160116f, 196 1032.46920021f, 1041.08681805f, 1049.71438560f, 1058.35183469f, 197 1066.99909811f, 1075.65610955f, 1084.32280357f, 1092.99911564f, 198 1101.68498204f, 1110.38033993f, 1119.08512727f, 1127.79928282f, 199 1136.52274614f, 1145.25545758f, 1153.99735821f, 1162.74838989f, 200 1171.50849518f, 1180.27761738f, 1189.05570047f, 1197.84268914f, 201 1206.63852876f, 1215.44316535f, 1224.25654560f, 1233.07861684f, 202 1241.90932703f, 1250.74862473f, 1259.59645914f, 1268.45278005f, 203 1277.31753781f, 1286.19068338f, 1295.07216828f, 1303.96194457f, 204 1312.85996488f, 1321.76618236f, 1330.68055071f, 1339.60302413f, 205 1348.53355734f, 1357.47210556f, 1366.41862452f, 1375.37307041f, 206 1384.33539991f, 1393.30557020f, 1402.28353887f, 1411.26926400f, 207 1420.26270412f, 1429.26381818f, 1438.27256558f, 1447.28890615f, 208 1456.31280014f, 1465.34420819f, 1474.38309138f, 1483.42941118f, 209 1492.48312945f, 1501.54420843f, 1510.61261078f, 1519.68829949f, 210 1528.77123795f, 1537.86138993f, 1546.95871952f, 1556.06319119f, 211 1565.17476976f, 1574.29342040f, 1583.41910860f, 1592.55180020f, 212 1601.69146137f, 1610.83805860f, 1619.99155871f, 1629.15192882f, 213 1638.31913637f, 1647.49314911f, 1656.67393509f, 1665.86146266f, 214 1675.05570047f, 1684.25661744f, 1693.46418280f, 1702.67836605f, 215 1711.89913698f, 1721.12646563f, 1730.36032233f, 1739.60067768f, 216 1748.84750254f, 1758.10076802f, 1767.36044551f, 1776.62650662f, 217 1785.89892323f, 1795.17766747f, 1804.46271172f, 1813.75402857f, 218 1823.05159087f, 1832.35537170f, 1841.66534438f, 1850.98148244f, 219 1860.30375965f, 1869.63214999f, 1878.96662767f, 1888.30716711f, 220 1897.65374295f, 1907.00633003f, 1916.36490342f, 1925.72943838f, 221 1935.09991037f, 1944.47629506f, 1953.85856831f, 1963.24670620f, 222 1972.64068498f, 1982.04048108f, 1991.44607117f, 2000.85743204f, 223 2010.27454072f, 2019.69737440f, 2029.12591044f, 2038.56012640f 224 }; 225 226 const VP8LPrefixCode kPrefixEncodeCode[PREFIX_LOOKUP_IDX_MAX] = { 227 { 0, 0}, { 0, 0}, { 1, 0}, { 2, 0}, { 3, 0}, { 4, 1}, { 4, 1}, { 5, 1}, 228 { 5, 1}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 7, 2}, { 7, 2}, { 7, 2}, 229 { 7, 2}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, 230 { 8, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, 231 { 9, 3}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, 232 {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, 233 {10, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, 234 {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, 235 {11, 4}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 236 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 237 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 238 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 239 {12, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 240 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 241 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 242 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 243 {13, 5}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 244 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 245 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 246 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 247 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 248 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 249 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 250 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 251 {14, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 252 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 253 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 254 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 255 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 256 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 257 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 258 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 259 {15, 6}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 260 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 261 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 262 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 263 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 264 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 265 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 266 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 267 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 268 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 269 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 270 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 271 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 272 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 273 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 274 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 275 {16, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 276 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 277 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 278 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 279 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 280 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 281 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 282 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 283 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 284 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 285 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 286 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 287 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 288 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 289 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 290 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 291 }; 292 293 const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX] = { 294 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 295 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 296 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 297 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 298 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 299 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 300 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 301 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 302 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 303 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 304 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 305 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 306 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 307 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 308 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 309 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 310 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 311 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 312 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 313 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 314 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 315 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 316 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 317 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 318 127, 319 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 320 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 321 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 322 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 323 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 324 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 325 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 326 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126 327 }; 328 329 static float FastSLog2Slow_C(uint32_t v) { 330 assert(v >= LOG_LOOKUP_IDX_MAX); 331 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { 332 int log_cnt = 0; 333 uint32_t y = 1; 334 int correction = 0; 335 const float v_f = (float)v; 336 const uint32_t orig_v = v; 337 do { 338 ++log_cnt; 339 v = v >> 1; 340 y = y << 1; 341 } while (v >= LOG_LOOKUP_IDX_MAX); 342 // vf = (2^log_cnt) * Xf; where y = 2^log_cnt and Xf < 256 343 // Xf = floor(Xf) * (1 + (v % y) / v) 344 // log2(Xf) = log2(floor(Xf)) + log2(1 + (v % y) / v) 345 // The correction factor: log(1 + d) ~ d; for very small d values, so 346 // log2(1 + (v % y) / v) ~ LOG_2_RECIPROCAL * (v % y)/v 347 // LOG_2_RECIPROCAL ~ 23/16 348 correction = (23 * (orig_v & (y - 1))) >> 4; 349 return v_f * (kLog2Table[v] + log_cnt) + correction; 350 } else { 351 return (float)(LOG_2_RECIPROCAL * v * log((double)v)); 352 } 353 } 354 355 static float FastLog2Slow_C(uint32_t v) { 356 assert(v >= LOG_LOOKUP_IDX_MAX); 357 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { 358 int log_cnt = 0; 359 uint32_t y = 1; 360 const uint32_t orig_v = v; 361 double log_2; 362 do { 363 ++log_cnt; 364 v = v >> 1; 365 y = y << 1; 366 } while (v >= LOG_LOOKUP_IDX_MAX); 367 log_2 = kLog2Table[v] + log_cnt; 368 if (orig_v >= APPROX_LOG_MAX) { 369 // Since the division is still expensive, add this correction factor only 370 // for large values of 'v'. 371 const int correction = (23 * (orig_v & (y - 1))) >> 4; 372 log_2 += (double)correction / orig_v; 373 } 374 return (float)log_2; 375 } else { 376 return (float)(LOG_2_RECIPROCAL * log((double)v)); 377 } 378 } 379 380 //------------------------------------------------------------------------------ 381 // Methods to calculate Entropy (Shannon). 382 383 // Compute the combined Shanon's entropy for distribution {X} and {X+Y} 384 static float CombinedShannonEntropy_C(const int X[256], const int Y[256]) { 385 int i; 386 double retval = 0.; 387 int sumX = 0, sumXY = 0; 388 for (i = 0; i < 256; ++i) { 389 const int x = X[i]; 390 if (x != 0) { 391 const int xy = x + Y[i]; 392 sumX += x; 393 retval -= VP8LFastSLog2(x); 394 sumXY += xy; 395 retval -= VP8LFastSLog2(xy); 396 } else if (Y[i] != 0) { 397 sumXY += Y[i]; 398 retval -= VP8LFastSLog2(Y[i]); 399 } 400 } 401 retval += VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY); 402 return (float)retval; 403 } 404 405 void VP8LBitEntropyInit(VP8LBitEntropy* const entropy) { 406 entropy->entropy = 0.; 407 entropy->sum = 0; 408 entropy->nonzeros = 0; 409 entropy->max_val = 0; 410 entropy->nonzero_code = VP8L_NON_TRIVIAL_SYM; 411 } 412 413 void VP8LBitsEntropyUnrefined(const uint32_t* const array, int n, 414 VP8LBitEntropy* const entropy) { 415 int i; 416 417 VP8LBitEntropyInit(entropy); 418 419 for (i = 0; i < n; ++i) { 420 if (array[i] != 0) { 421 entropy->sum += array[i]; 422 entropy->nonzero_code = i; 423 ++entropy->nonzeros; 424 entropy->entropy -= VP8LFastSLog2(array[i]); 425 if (entropy->max_val < array[i]) { 426 entropy->max_val = array[i]; 427 } 428 } 429 } 430 entropy->entropy += VP8LFastSLog2(entropy->sum); 431 } 432 433 static WEBP_INLINE void GetEntropyUnrefinedHelper( 434 uint32_t val, int i, uint32_t* const val_prev, int* const i_prev, 435 VP8LBitEntropy* const bit_entropy, VP8LStreaks* const stats) { 436 const int streak = i - *i_prev; 437 438 // Gather info for the bit entropy. 439 if (*val_prev != 0) { 440 bit_entropy->sum += (*val_prev) * streak; 441 bit_entropy->nonzeros += streak; 442 bit_entropy->nonzero_code = *i_prev; 443 bit_entropy->entropy -= VP8LFastSLog2(*val_prev) * streak; 444 if (bit_entropy->max_val < *val_prev) { 445 bit_entropy->max_val = *val_prev; 446 } 447 } 448 449 // Gather info for the Huffman cost. 450 stats->counts[*val_prev != 0] += (streak > 3); 451 stats->streaks[*val_prev != 0][(streak > 3)] += streak; 452 453 *val_prev = val; 454 *i_prev = i; 455 } 456 457 static void GetEntropyUnrefined_C(const uint32_t X[], int length, 458 VP8LBitEntropy* const bit_entropy, 459 VP8LStreaks* const stats) { 460 int i; 461 int i_prev = 0; 462 uint32_t x_prev = X[0]; 463 464 memset(stats, 0, sizeof(*stats)); 465 VP8LBitEntropyInit(bit_entropy); 466 467 for (i = 1; i < length; ++i) { 468 const uint32_t x = X[i]; 469 if (x != x_prev) { 470 GetEntropyUnrefinedHelper(x, i, &x_prev, &i_prev, bit_entropy, stats); 471 } 472 } 473 GetEntropyUnrefinedHelper(0, i, &x_prev, &i_prev, bit_entropy, stats); 474 475 bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum); 476 } 477 478 static void GetCombinedEntropyUnrefined_C(const uint32_t X[], 479 const uint32_t Y[], 480 int length, 481 VP8LBitEntropy* const bit_entropy, 482 VP8LStreaks* const stats) { 483 int i = 1; 484 int i_prev = 0; 485 uint32_t xy_prev = X[0] + Y[0]; 486 487 memset(stats, 0, sizeof(*stats)); 488 VP8LBitEntropyInit(bit_entropy); 489 490 for (i = 1; i < length; ++i) { 491 const uint32_t xy = X[i] + Y[i]; 492 if (xy != xy_prev) { 493 GetEntropyUnrefinedHelper(xy, i, &xy_prev, &i_prev, bit_entropy, stats); 494 } 495 } 496 GetEntropyUnrefinedHelper(0, i, &xy_prev, &i_prev, bit_entropy, stats); 497 498 bit_entropy->entropy += VP8LFastSLog2(bit_entropy->sum); 499 } 500 501 //------------------------------------------------------------------------------ 502 503 void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, int num_pixels) { 504 int i; 505 for (i = 0; i < num_pixels; ++i) { 506 const int argb = argb_data[i]; 507 const int green = (argb >> 8) & 0xff; 508 const uint32_t new_r = (((argb >> 16) & 0xff) - green) & 0xff; 509 const uint32_t new_b = (((argb >> 0) & 0xff) - green) & 0xff; 510 argb_data[i] = (argb & 0xff00ff00u) | (new_r << 16) | new_b; 511 } 512 } 513 514 static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) { 515 return ((int)color_pred * color) >> 5; 516 } 517 518 void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data, 519 int num_pixels) { 520 int i; 521 for (i = 0; i < num_pixels; ++i) { 522 const uint32_t argb = data[i]; 523 const uint32_t green = argb >> 8; 524 const uint32_t red = argb >> 16; 525 int new_red = red & 0xff; 526 int new_blue = argb & 0xff; 527 new_red -= ColorTransformDelta(m->green_to_red_, green); 528 new_red &= 0xff; 529 new_blue -= ColorTransformDelta(m->green_to_blue_, green); 530 new_blue -= ColorTransformDelta(m->red_to_blue_, red); 531 new_blue &= 0xff; 532 data[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue); 533 } 534 } 535 536 static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red, 537 uint32_t argb) { 538 const uint32_t green = argb >> 8; 539 int new_red = argb >> 16; 540 new_red -= ColorTransformDelta(green_to_red, green); 541 return (new_red & 0xff); 542 } 543 544 static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue, 545 uint8_t red_to_blue, 546 uint32_t argb) { 547 const uint32_t green = argb >> 8; 548 const uint32_t red = argb >> 16; 549 uint8_t new_blue = argb; 550 new_blue -= ColorTransformDelta(green_to_blue, green); 551 new_blue -= ColorTransformDelta(red_to_blue, red); 552 return (new_blue & 0xff); 553 } 554 555 void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride, 556 int tile_width, int tile_height, 557 int green_to_red, int histo[]) { 558 while (tile_height-- > 0) { 559 int x; 560 for (x = 0; x < tile_width; ++x) { 561 ++histo[TransformColorRed(green_to_red, argb[x])]; 562 } 563 argb += stride; 564 } 565 } 566 567 void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride, 568 int tile_width, int tile_height, 569 int green_to_blue, int red_to_blue, 570 int histo[]) { 571 while (tile_height-- > 0) { 572 int x; 573 for (x = 0; x < tile_width; ++x) { 574 ++histo[TransformColorBlue(green_to_blue, red_to_blue, argb[x])]; 575 } 576 argb += stride; 577 } 578 } 579 580 //------------------------------------------------------------------------------ 581 582 static int VectorMismatch_C(const uint32_t* const array1, 583 const uint32_t* const array2, int length) { 584 int match_len = 0; 585 586 while (match_len < length && array1[match_len] == array2[match_len]) { 587 ++match_len; 588 } 589 return match_len; 590 } 591 592 // Bundles multiple (1, 2, 4 or 8) pixels into a single pixel. 593 void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits, 594 uint32_t* dst) { 595 int x; 596 if (xbits > 0) { 597 const int bit_depth = 1 << (3 - xbits); 598 const int mask = (1 << xbits) - 1; 599 uint32_t code = 0xff000000; 600 for (x = 0; x < width; ++x) { 601 const int xsub = x & mask; 602 if (xsub == 0) { 603 code = 0xff000000; 604 } 605 code |= row[x] << (8 + bit_depth * xsub); 606 dst[x >> xbits] = code; 607 } 608 } else { 609 for (x = 0; x < width; ++x) dst[x] = 0xff000000 | (row[x] << 8); 610 } 611 } 612 613 //------------------------------------------------------------------------------ 614 615 static double ExtraCost_C(const uint32_t* population, int length) { 616 int i; 617 double cost = 0.; 618 for (i = 2; i < length - 2; ++i) cost += (i >> 1) * population[i + 2]; 619 return cost; 620 } 621 622 static double ExtraCostCombined_C(const uint32_t* X, const uint32_t* Y, 623 int length) { 624 int i; 625 double cost = 0.; 626 for (i = 2; i < length - 2; ++i) { 627 const int xy = X[i + 2] + Y[i + 2]; 628 cost += (i >> 1) * xy; 629 } 630 return cost; 631 } 632 633 //------------------------------------------------------------------------------ 634 635 static void AddVector_C(const uint32_t* a, const uint32_t* b, uint32_t* out, 636 int size) { 637 int i; 638 for (i = 0; i < size; ++i) out[i] = a[i] + b[i]; 639 } 640 641 static void AddVectorEq_C(const uint32_t* a, uint32_t* out, int size) { 642 int i; 643 for (i = 0; i < size; ++i) out[i] += a[i]; 644 } 645 646 #define ADD(X, ARG, LEN) do { \ 647 if (a->is_used_[X]) { \ 648 if (b->is_used_[X]) { \ 649 VP8LAddVector(a->ARG, b->ARG, out->ARG, (LEN)); \ 650 } else { \ 651 memcpy(&out->ARG[0], &a->ARG[0], (LEN) * sizeof(out->ARG[0])); \ 652 } \ 653 } else if (b->is_used_[X]) { \ 654 memcpy(&out->ARG[0], &b->ARG[0], (LEN) * sizeof(out->ARG[0])); \ 655 } else { \ 656 memset(&out->ARG[0], 0, (LEN) * sizeof(out->ARG[0])); \ 657 } \ 658 } while (0) 659 660 #define ADD_EQ(X, ARG, LEN) do { \ 661 if (a->is_used_[X]) { \ 662 if (out->is_used_[X]) { \ 663 VP8LAddVectorEq(a->ARG, out->ARG, (LEN)); \ 664 } else { \ 665 memcpy(&out->ARG[0], &a->ARG[0], (LEN) * sizeof(out->ARG[0])); \ 666 } \ 667 } \ 668 } while (0) 669 670 void VP8LHistogramAdd(const VP8LHistogram* const a, 671 const VP8LHistogram* const b, VP8LHistogram* const out) { 672 int i; 673 const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_); 674 assert(a->palette_code_bits_ == b->palette_code_bits_); 675 676 if (b != out) { 677 ADD(0, literal_, literal_size); 678 ADD(1, red_, NUM_LITERAL_CODES); 679 ADD(2, blue_, NUM_LITERAL_CODES); 680 ADD(3, alpha_, NUM_LITERAL_CODES); 681 ADD(4, distance_, NUM_DISTANCE_CODES); 682 for (i = 0; i < 5; ++i) { 683 out->is_used_[i] = (a->is_used_[i] | b->is_used_[i]); 684 } 685 } else { 686 ADD_EQ(0, literal_, literal_size); 687 ADD_EQ(1, red_, NUM_LITERAL_CODES); 688 ADD_EQ(2, blue_, NUM_LITERAL_CODES); 689 ADD_EQ(3, alpha_, NUM_LITERAL_CODES); 690 ADD_EQ(4, distance_, NUM_DISTANCE_CODES); 691 for (i = 0; i < 5; ++i) out->is_used_[i] |= a->is_used_[i]; 692 } 693 } 694 #undef ADD 695 #undef ADD_EQ 696 697 //------------------------------------------------------------------------------ 698 // Image transforms. 699 700 static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) { 701 return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1); 702 } 703 704 static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) { 705 return Average2(Average2(a0, a2), a1); 706 } 707 708 static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1, 709 uint32_t a2, uint32_t a3) { 710 return Average2(Average2(a0, a1), Average2(a2, a3)); 711 } 712 713 static WEBP_INLINE uint32_t Clip255(uint32_t a) { 714 if (a < 256) { 715 return a; 716 } 717 // return 0, when a is a negative integer. 718 // return 255, when a is positive. 719 return ~a >> 24; 720 } 721 722 static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) { 723 return Clip255(a + b - c); 724 } 725 726 static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1, 727 uint32_t c2) { 728 const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24); 729 const int r = AddSubtractComponentFull((c0 >> 16) & 0xff, 730 (c1 >> 16) & 0xff, 731 (c2 >> 16) & 0xff); 732 const int g = AddSubtractComponentFull((c0 >> 8) & 0xff, 733 (c1 >> 8) & 0xff, 734 (c2 >> 8) & 0xff); 735 const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff); 736 return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b; 737 } 738 739 static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) { 740 return Clip255(a + (a - b) / 2); 741 } 742 743 static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1, 744 uint32_t c2) { 745 const uint32_t ave = Average2(c0, c1); 746 const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24); 747 const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff); 748 const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff); 749 const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff); 750 return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b; 751 } 752 753 // gcc-4.9 on ARM generates incorrect code in Select() when Sub3() is inlined. 754 #if defined(__arm__) && \ 755 (LOCAL_GCC_VERSION == 0x409 || LOCAL_GCC_VERSION == 0x408) 756 # define LOCAL_INLINE __attribute__ ((noinline)) 757 #else 758 # define LOCAL_INLINE WEBP_INLINE 759 #endif 760 761 static LOCAL_INLINE int Sub3(int a, int b, int c) { 762 const int pb = b - c; 763 const int pa = a - c; 764 return abs(pb) - abs(pa); 765 } 766 767 #undef LOCAL_INLINE 768 769 static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) { 770 const int pa_minus_pb = 771 Sub3((a >> 24) , (b >> 24) , (c >> 24) ) + 772 Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) + 773 Sub3((a >> 8) & 0xff, (b >> 8) & 0xff, (c >> 8) & 0xff) + 774 Sub3((a ) & 0xff, (b ) & 0xff, (c ) & 0xff); 775 return (pa_minus_pb <= 0) ? a : b; 776 } 777 778 //------------------------------------------------------------------------------ 779 // Predictors 780 781 static uint32_t Predictor2(uint32_t left, const uint32_t* const top) { 782 (void)left; 783 return top[0]; 784 } 785 static uint32_t Predictor3(uint32_t left, const uint32_t* const top) { 786 (void)left; 787 return top[1]; 788 } 789 static uint32_t Predictor4(uint32_t left, const uint32_t* const top) { 790 (void)left; 791 return top[-1]; 792 } 793 static uint32_t Predictor5(uint32_t left, const uint32_t* const top) { 794 const uint32_t pred = Average3(left, top[0], top[1]); 795 return pred; 796 } 797 static uint32_t Predictor6(uint32_t left, const uint32_t* const top) { 798 const uint32_t pred = Average2(left, top[-1]); 799 return pred; 800 } 801 static uint32_t Predictor7(uint32_t left, const uint32_t* const top) { 802 const uint32_t pred = Average2(left, top[0]); 803 return pred; 804 } 805 static uint32_t Predictor8(uint32_t left, const uint32_t* const top) { 806 const uint32_t pred = Average2(top[-1], top[0]); 807 (void)left; 808 return pred; 809 } 810 static uint32_t Predictor9(uint32_t left, const uint32_t* const top) { 811 const uint32_t pred = Average2(top[0], top[1]); 812 (void)left; 813 return pred; 814 } 815 static uint32_t Predictor10(uint32_t left, const uint32_t* const top) { 816 const uint32_t pred = Average4(left, top[-1], top[0], top[1]); 817 return pred; 818 } 819 static uint32_t Predictor11(uint32_t left, const uint32_t* const top) { 820 const uint32_t pred = Select(top[0], left, top[-1]); 821 return pred; 822 } 823 static uint32_t Predictor12(uint32_t left, const uint32_t* const top) { 824 const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]); 825 return pred; 826 } 827 static uint32_t Predictor13(uint32_t left, const uint32_t* const top) { 828 const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]); 829 return pred; 830 } 831 832 //------------------------------------------------------------------------------ 833 834 static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper, 835 int num_pixels, uint32_t* out) { 836 int i; 837 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], ARGB_BLACK); 838 (void)upper; 839 } 840 841 static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper, 842 int num_pixels, uint32_t* out) { 843 int i; 844 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], in[i - 1]); 845 (void)upper; 846 } 847 848 GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C) 849 GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C) 850 GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C) 851 GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C) 852 GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C) 853 GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C) 854 GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C) 855 GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C) 856 GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C) 857 GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C) 858 GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C) 859 GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C) 860 861 //------------------------------------------------------------------------------ 862 863 VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; 864 865 VP8LTransformColorFunc VP8LTransformColor; 866 867 VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms; 868 VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms; 869 870 VP8LFastLog2SlowFunc VP8LFastLog2Slow; 871 VP8LFastLog2SlowFunc VP8LFastSLog2Slow; 872 873 VP8LCostFunc VP8LExtraCost; 874 VP8LCostCombinedFunc VP8LExtraCostCombined; 875 VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy; 876 877 VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined; 878 VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined; 879 880 VP8LAddVectorFunc VP8LAddVector; 881 VP8LAddVectorEqFunc VP8LAddVectorEq; 882 883 VP8LVectorMismatchFunc VP8LVectorMismatch; 884 VP8LBundleColorMapFunc VP8LBundleColorMap; 885 886 VP8LPredictorAddSubFunc VP8LPredictorsSub[16]; 887 VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16]; 888 889 extern void VP8LEncDspInitSSE2(void); 890 extern void VP8LEncDspInitSSE41(void); 891 extern void VP8LEncDspInitNEON(void); 892 extern void VP8LEncDspInitMIPS32(void); 893 extern void VP8LEncDspInitMIPSdspR2(void); 894 extern void VP8LEncDspInitMSA(void); 895 896 WEBP_DSP_INIT_FUNC(VP8LEncDspInit) { 897 VP8LDspInit(); 898 899 #if !WEBP_NEON_OMIT_C_CODE 900 VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C; 901 902 VP8LTransformColor = VP8LTransformColor_C; 903 #endif 904 905 VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C; 906 VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C; 907 908 VP8LFastLog2Slow = FastLog2Slow_C; 909 VP8LFastSLog2Slow = FastSLog2Slow_C; 910 911 VP8LExtraCost = ExtraCost_C; 912 VP8LExtraCostCombined = ExtraCostCombined_C; 913 VP8LCombinedShannonEntropy = CombinedShannonEntropy_C; 914 915 VP8LGetEntropyUnrefined = GetEntropyUnrefined_C; 916 VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C; 917 918 VP8LAddVector = AddVector_C; 919 VP8LAddVectorEq = AddVectorEq_C; 920 921 VP8LVectorMismatch = VectorMismatch_C; 922 VP8LBundleColorMap = VP8LBundleColorMap_C; 923 924 VP8LPredictorsSub[0] = PredictorSub0_C; 925 VP8LPredictorsSub[1] = PredictorSub1_C; 926 VP8LPredictorsSub[2] = PredictorSub2_C; 927 VP8LPredictorsSub[3] = PredictorSub3_C; 928 VP8LPredictorsSub[4] = PredictorSub4_C; 929 VP8LPredictorsSub[5] = PredictorSub5_C; 930 VP8LPredictorsSub[6] = PredictorSub6_C; 931 VP8LPredictorsSub[7] = PredictorSub7_C; 932 VP8LPredictorsSub[8] = PredictorSub8_C; 933 VP8LPredictorsSub[9] = PredictorSub9_C; 934 VP8LPredictorsSub[10] = PredictorSub10_C; 935 VP8LPredictorsSub[11] = PredictorSub11_C; 936 VP8LPredictorsSub[12] = PredictorSub12_C; 937 VP8LPredictorsSub[13] = PredictorSub13_C; 938 VP8LPredictorsSub[14] = PredictorSub0_C; // <- padding security sentinels 939 VP8LPredictorsSub[15] = PredictorSub0_C; 940 941 VP8LPredictorsSub_C[0] = PredictorSub0_C; 942 VP8LPredictorsSub_C[1] = PredictorSub1_C; 943 VP8LPredictorsSub_C[2] = PredictorSub2_C; 944 VP8LPredictorsSub_C[3] = PredictorSub3_C; 945 VP8LPredictorsSub_C[4] = PredictorSub4_C; 946 VP8LPredictorsSub_C[5] = PredictorSub5_C; 947 VP8LPredictorsSub_C[6] = PredictorSub6_C; 948 VP8LPredictorsSub_C[7] = PredictorSub7_C; 949 VP8LPredictorsSub_C[8] = PredictorSub8_C; 950 VP8LPredictorsSub_C[9] = PredictorSub9_C; 951 VP8LPredictorsSub_C[10] = PredictorSub10_C; 952 VP8LPredictorsSub_C[11] = PredictorSub11_C; 953 VP8LPredictorsSub_C[12] = PredictorSub12_C; 954 VP8LPredictorsSub_C[13] = PredictorSub13_C; 955 VP8LPredictorsSub_C[14] = PredictorSub0_C; // <- padding security sentinels 956 VP8LPredictorsSub_C[15] = PredictorSub0_C; 957 958 // If defined, use CPUInfo() to overwrite some pointers with faster versions. 959 if (VP8GetCPUInfo != NULL) { 960 #if defined(WEBP_USE_SSE2) 961 if (VP8GetCPUInfo(kSSE2)) { 962 VP8LEncDspInitSSE2(); 963 #if defined(WEBP_USE_SSE41) 964 if (VP8GetCPUInfo(kSSE4_1)) { 965 VP8LEncDspInitSSE41(); 966 } 967 #endif 968 } 969 #endif 970 #if defined(WEBP_USE_MIPS32) 971 if (VP8GetCPUInfo(kMIPS32)) { 972 VP8LEncDspInitMIPS32(); 973 } 974 #endif 975 #if defined(WEBP_USE_MIPS_DSP_R2) 976 if (VP8GetCPUInfo(kMIPSdspR2)) { 977 VP8LEncDspInitMIPSdspR2(); 978 } 979 #endif 980 #if defined(WEBP_USE_MSA) 981 if (VP8GetCPUInfo(kMSA)) { 982 VP8LEncDspInitMSA(); 983 } 984 #endif 985 } 986 987 #if defined(WEBP_USE_NEON) 988 if (WEBP_NEON_OMIT_C_CODE || 989 (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) { 990 VP8LEncDspInitNEON(); 991 } 992 #endif 993 994 assert(VP8LSubtractGreenFromBlueAndRed != NULL); 995 assert(VP8LTransformColor != NULL); 996 assert(VP8LCollectColorBlueTransforms != NULL); 997 assert(VP8LCollectColorRedTransforms != NULL); 998 assert(VP8LFastLog2Slow != NULL); 999 assert(VP8LFastSLog2Slow != NULL); 1000 assert(VP8LExtraCost != NULL); 1001 assert(VP8LExtraCostCombined != NULL); 1002 assert(VP8LCombinedShannonEntropy != NULL); 1003 assert(VP8LGetEntropyUnrefined != NULL); 1004 assert(VP8LGetCombinedEntropyUnrefined != NULL); 1005 assert(VP8LAddVector != NULL); 1006 assert(VP8LAddVectorEq != NULL); 1007 assert(VP8LVectorMismatch != NULL); 1008 assert(VP8LBundleColorMap != NULL); 1009 assert(VP8LPredictorsSub[0] != NULL); 1010 assert(VP8LPredictorsSub[1] != NULL); 1011 assert(VP8LPredictorsSub[2] != NULL); 1012 assert(VP8LPredictorsSub[3] != NULL); 1013 assert(VP8LPredictorsSub[4] != NULL); 1014 assert(VP8LPredictorsSub[5] != NULL); 1015 assert(VP8LPredictorsSub[6] != NULL); 1016 assert(VP8LPredictorsSub[7] != NULL); 1017 assert(VP8LPredictorsSub[8] != NULL); 1018 assert(VP8LPredictorsSub[9] != NULL); 1019 assert(VP8LPredictorsSub[10] != NULL); 1020 assert(VP8LPredictorsSub[11] != NULL); 1021 assert(VP8LPredictorsSub[12] != NULL); 1022 assert(VP8LPredictorsSub[13] != NULL); 1023 assert(VP8LPredictorsSub[14] != NULL); 1024 assert(VP8LPredictorsSub[15] != NULL); 1025 assert(VP8LPredictorsSub_C[0] != NULL); 1026 assert(VP8LPredictorsSub_C[1] != NULL); 1027 assert(VP8LPredictorsSub_C[2] != NULL); 1028 assert(VP8LPredictorsSub_C[3] != NULL); 1029 assert(VP8LPredictorsSub_C[4] != NULL); 1030 assert(VP8LPredictorsSub_C[5] != NULL); 1031 assert(VP8LPredictorsSub_C[6] != NULL); 1032 assert(VP8LPredictorsSub_C[7] != NULL); 1033 assert(VP8LPredictorsSub_C[8] != NULL); 1034 assert(VP8LPredictorsSub_C[9] != NULL); 1035 assert(VP8LPredictorsSub_C[10] != NULL); 1036 assert(VP8LPredictorsSub_C[11] != NULL); 1037 assert(VP8LPredictorsSub_C[12] != NULL); 1038 assert(VP8LPredictorsSub_C[13] != NULL); 1039 assert(VP8LPredictorsSub_C[14] != NULL); 1040 assert(VP8LPredictorsSub_C[15] != NULL); 1041 } 1042 1043 //------------------------------------------------------------------------------ 1044
