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@gmail.com)
13 // Jyrki Alakuijala (jyrki@google.com)
14 // Urvang Joshi (urvang@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
FastSLog2Slow_C(uint32_t v)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
FastLog2Slow_C(uint32_t v)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}
CombinedShannonEntropy_C(const int X[256],const int Y[256])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
VP8LBitEntropyInit(VP8LBitEntropy * const entropy)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
VP8LBitsEntropyUnrefined(const uint32_t * const array,int n,VP8LBitEntropy * const entropy)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
GetEntropyUnrefinedHelper(uint32_t val,int i,uint32_t * const val_prev,int * const i_prev,VP8LBitEntropy * const bit_entropy,VP8LStreaks * const stats)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
GetEntropyUnrefined_C(const uint32_t X[],int length,VP8LBitEntropy * const bit_entropy,VP8LStreaks * const stats)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
GetCombinedEntropyUnrefined_C(const uint32_t X[],const uint32_t Y[],int length,VP8LBitEntropy * const bit_entropy,VP8LStreaks * const stats)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
VP8LSubtractGreenFromBlueAndRed_C(uint32_t * argb_data,int num_pixels)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
ColorTransformDelta(int8_t color_pred,int8_t color)514 static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
515 return ((int)color_pred * color) >> 5;
516 }
517
VP8LTransformColor_C(const VP8LMultipliers * const m,uint32_t * data,int num_pixels)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
TransformColorRed(uint8_t green_to_red,uint32_t argb)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
TransformColorBlue(uint8_t green_to_blue,uint8_t red_to_blue,uint32_t argb)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
VP8LCollectColorRedTransforms_C(const uint32_t * argb,int stride,int tile_width,int tile_height,int green_to_red,int histo[])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
VP8LCollectColorBlueTransforms_C(const uint32_t * argb,int stride,int tile_width,int tile_height,int green_to_blue,int red_to_blue,int histo[])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
VectorMismatch_C(const uint32_t * const array1,const uint32_t * const array2,int length)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.
VP8LBundleColorMap_C(const uint8_t * const row,int width,int xbits,uint32_t * dst)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
ExtraCost_C(const uint32_t * population,int length)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
ExtraCostCombined_C(const uint32_t * X,const uint32_t * Y,int length)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
HistogramAdd_C(const VP8LHistogram * const a,const VP8LHistogram * const b,VP8LHistogram * const out)635 static void HistogramAdd_C(const VP8LHistogram* const a,
636 const VP8LHistogram* const b,
637 VP8LHistogram* const out) {
638 int i;
639 const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
640 assert(a->palette_code_bits_ == b->palette_code_bits_);
641 if (b != out) {
642 for (i = 0; i < literal_size; ++i) {
643 out->literal_[i] = a->literal_[i] + b->literal_[i];
644 }
645 for (i = 0; i < NUM_DISTANCE_CODES; ++i) {
646 out->distance_[i] = a->distance_[i] + b->distance_[i];
647 }
648 for (i = 0; i < NUM_LITERAL_CODES; ++i) {
649 out->red_[i] = a->red_[i] + b->red_[i];
650 out->blue_[i] = a->blue_[i] + b->blue_[i];
651 out->alpha_[i] = a->alpha_[i] + b->alpha_[i];
652 }
653 } else {
654 for (i = 0; i < literal_size; ++i) {
655 out->literal_[i] += a->literal_[i];
656 }
657 for (i = 0; i < NUM_DISTANCE_CODES; ++i) {
658 out->distance_[i] += a->distance_[i];
659 }
660 for (i = 0; i < NUM_LITERAL_CODES; ++i) {
661 out->red_[i] += a->red_[i];
662 out->blue_[i] += a->blue_[i];
663 out->alpha_[i] += a->alpha_[i];
664 }
665 }
666 }
667
668 //------------------------------------------------------------------------------
669 // Image transforms.
670
Average2(uint32_t a0,uint32_t a1)671 static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
672 return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
673 }
674
Average3(uint32_t a0,uint32_t a1,uint32_t a2)675 static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) {
676 return Average2(Average2(a0, a2), a1);
677 }
678
Average4(uint32_t a0,uint32_t a1,uint32_t a2,uint32_t a3)679 static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,
680 uint32_t a2, uint32_t a3) {
681 return Average2(Average2(a0, a1), Average2(a2, a3));
682 }
683
Clip255(uint32_t a)684 static WEBP_INLINE uint32_t Clip255(uint32_t a) {
685 if (a < 256) {
686 return a;
687 }
688 // return 0, when a is a negative integer.
689 // return 255, when a is positive.
690 return ~a >> 24;
691 }
692
AddSubtractComponentFull(int a,int b,int c)693 static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
694 return Clip255(a + b - c);
695 }
696
ClampedAddSubtractFull(uint32_t c0,uint32_t c1,uint32_t c2)697 static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,
698 uint32_t c2) {
699 const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
700 const int r = AddSubtractComponentFull((c0 >> 16) & 0xff,
701 (c1 >> 16) & 0xff,
702 (c2 >> 16) & 0xff);
703 const int g = AddSubtractComponentFull((c0 >> 8) & 0xff,
704 (c1 >> 8) & 0xff,
705 (c2 >> 8) & 0xff);
706 const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
707 return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
708 }
709
AddSubtractComponentHalf(int a,int b)710 static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {
711 return Clip255(a + (a - b) / 2);
712 }
713
ClampedAddSubtractHalf(uint32_t c0,uint32_t c1,uint32_t c2)714 static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
715 uint32_t c2) {
716 const uint32_t ave = Average2(c0, c1);
717 const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24);
718 const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff);
719 const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff);
720 const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff);
721 return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
722 }
723
724 // gcc-4.9 on ARM generates incorrect code in Select() when Sub3() is inlined.
725 #if defined(__arm__) && \
726 (LOCAL_GCC_VERSION == 0x409 || LOCAL_GCC_VERSION == 0x408)
727 # define LOCAL_INLINE __attribute__ ((noinline))
728 #else
729 # define LOCAL_INLINE WEBP_INLINE
730 #endif
731
Sub3(int a,int b,int c)732 static LOCAL_INLINE int Sub3(int a, int b, int c) {
733 const int pb = b - c;
734 const int pa = a - c;
735 return abs(pb) - abs(pa);
736 }
737
738 #undef LOCAL_INLINE
739
Select(uint32_t a,uint32_t b,uint32_t c)740 static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
741 const int pa_minus_pb =
742 Sub3((a >> 24) , (b >> 24) , (c >> 24) ) +
743 Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
744 Sub3((a >> 8) & 0xff, (b >> 8) & 0xff, (c >> 8) & 0xff) +
745 Sub3((a ) & 0xff, (b ) & 0xff, (c ) & 0xff);
746 return (pa_minus_pb <= 0) ? a : b;
747 }
748
749 //------------------------------------------------------------------------------
750 // Predictors
751
Predictor2(uint32_t left,const uint32_t * const top)752 static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {
753 (void)left;
754 return top[0];
755 }
Predictor3(uint32_t left,const uint32_t * const top)756 static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {
757 (void)left;
758 return top[1];
759 }
Predictor4(uint32_t left,const uint32_t * const top)760 static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {
761 (void)left;
762 return top[-1];
763 }
Predictor5(uint32_t left,const uint32_t * const top)764 static uint32_t Predictor5(uint32_t left, const uint32_t* const top) {
765 const uint32_t pred = Average3(left, top[0], top[1]);
766 return pred;
767 }
Predictor6(uint32_t left,const uint32_t * const top)768 static uint32_t Predictor6(uint32_t left, const uint32_t* const top) {
769 const uint32_t pred = Average2(left, top[-1]);
770 return pred;
771 }
Predictor7(uint32_t left,const uint32_t * const top)772 static uint32_t Predictor7(uint32_t left, const uint32_t* const top) {
773 const uint32_t pred = Average2(left, top[0]);
774 return pred;
775 }
Predictor8(uint32_t left,const uint32_t * const top)776 static uint32_t Predictor8(uint32_t left, const uint32_t* const top) {
777 const uint32_t pred = Average2(top[-1], top[0]);
778 (void)left;
779 return pred;
780 }
Predictor9(uint32_t left,const uint32_t * const top)781 static uint32_t Predictor9(uint32_t left, const uint32_t* const top) {
782 const uint32_t pred = Average2(top[0], top[1]);
783 (void)left;
784 return pred;
785 }
Predictor10(uint32_t left,const uint32_t * const top)786 static uint32_t Predictor10(uint32_t left, const uint32_t* const top) {
787 const uint32_t pred = Average4(left, top[-1], top[0], top[1]);
788 return pred;
789 }
Predictor11(uint32_t left,const uint32_t * const top)790 static uint32_t Predictor11(uint32_t left, const uint32_t* const top) {
791 const uint32_t pred = Select(top[0], left, top[-1]);
792 return pred;
793 }
Predictor12(uint32_t left,const uint32_t * const top)794 static uint32_t Predictor12(uint32_t left, const uint32_t* const top) {
795 const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);
796 return pred;
797 }
Predictor13(uint32_t left,const uint32_t * const top)798 static uint32_t Predictor13(uint32_t left, const uint32_t* const top) {
799 const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);
800 return pred;
801 }
802
803 //------------------------------------------------------------------------------
804
PredictorSub0_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)805 static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper,
806 int num_pixels, uint32_t* out) {
807 int i;
808 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], ARGB_BLACK);
809 (void)upper;
810 }
811
PredictorSub1_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)812 static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper,
813 int num_pixels, uint32_t* out) {
814 int i;
815 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], in[i - 1]);
816 (void)upper;
817 }
818
819 GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C)
820 GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C)
821 GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C)
822 GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C)
823 GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C)
824 GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C)
825 GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C)
826 GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C)
827 GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C)
828 GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C)
829 GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C)
830 GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C)
831
832 //------------------------------------------------------------------------------
833
834 VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed;
835
836 VP8LTransformColorFunc VP8LTransformColor;
837
838 VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms;
839 VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms;
840
841 VP8LFastLog2SlowFunc VP8LFastLog2Slow;
842 VP8LFastLog2SlowFunc VP8LFastSLog2Slow;
843
844 VP8LCostFunc VP8LExtraCost;
845 VP8LCostCombinedFunc VP8LExtraCostCombined;
846 VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy;
847
848 VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined;
849 VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined;
850
851 VP8LHistogramAddFunc VP8LHistogramAdd;
852
853 VP8LVectorMismatchFunc VP8LVectorMismatch;
854 VP8LBundleColorMapFunc VP8LBundleColorMap;
855
856 VP8LPredictorAddSubFunc VP8LPredictorsSub[16];
857 VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16];
858
859 extern void VP8LEncDspInitSSE2(void);
860 extern void VP8LEncDspInitSSE41(void);
861 extern void VP8LEncDspInitNEON(void);
862 extern void VP8LEncDspInitMIPS32(void);
863 extern void VP8LEncDspInitMIPSdspR2(void);
864 extern void VP8LEncDspInitMSA(void);
865
866 static volatile VP8CPUInfo lossless_enc_last_cpuinfo_used =
867 (VP8CPUInfo)&lossless_enc_last_cpuinfo_used;
868
VP8LEncDspInit(void)869 WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInit(void) {
870 if (lossless_enc_last_cpuinfo_used == VP8GetCPUInfo) return;
871
872 VP8LDspInit();
873
874 #if !WEBP_NEON_OMIT_C_CODE
875 VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C;
876
877 VP8LTransformColor = VP8LTransformColor_C;
878 #endif
879
880 VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C;
881 VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C;
882
883 VP8LFastLog2Slow = FastLog2Slow_C;
884 VP8LFastSLog2Slow = FastSLog2Slow_C;
885
886 VP8LExtraCost = ExtraCost_C;
887 VP8LExtraCostCombined = ExtraCostCombined_C;
888 VP8LCombinedShannonEntropy = CombinedShannonEntropy_C;
889
890 VP8LGetEntropyUnrefined = GetEntropyUnrefined_C;
891 VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C;
892
893 VP8LHistogramAdd = HistogramAdd_C;
894
895 VP8LVectorMismatch = VectorMismatch_C;
896 VP8LBundleColorMap = VP8LBundleColorMap_C;
897
898 VP8LPredictorsSub[0] = PredictorSub0_C;
899 VP8LPredictorsSub[1] = PredictorSub1_C;
900 VP8LPredictorsSub[2] = PredictorSub2_C;
901 VP8LPredictorsSub[3] = PredictorSub3_C;
902 VP8LPredictorsSub[4] = PredictorSub4_C;
903 VP8LPredictorsSub[5] = PredictorSub5_C;
904 VP8LPredictorsSub[6] = PredictorSub6_C;
905 VP8LPredictorsSub[7] = PredictorSub7_C;
906 VP8LPredictorsSub[8] = PredictorSub8_C;
907 VP8LPredictorsSub[9] = PredictorSub9_C;
908 VP8LPredictorsSub[10] = PredictorSub10_C;
909 VP8LPredictorsSub[11] = PredictorSub11_C;
910 VP8LPredictorsSub[12] = PredictorSub12_C;
911 VP8LPredictorsSub[13] = PredictorSub13_C;
912 VP8LPredictorsSub[14] = PredictorSub0_C; // <- padding security sentinels
913 VP8LPredictorsSub[15] = PredictorSub0_C;
914
915 VP8LPredictorsSub_C[0] = PredictorSub0_C;
916 VP8LPredictorsSub_C[1] = PredictorSub1_C;
917 VP8LPredictorsSub_C[2] = PredictorSub2_C;
918 VP8LPredictorsSub_C[3] = PredictorSub3_C;
919 VP8LPredictorsSub_C[4] = PredictorSub4_C;
920 VP8LPredictorsSub_C[5] = PredictorSub5_C;
921 VP8LPredictorsSub_C[6] = PredictorSub6_C;
922 VP8LPredictorsSub_C[7] = PredictorSub7_C;
923 VP8LPredictorsSub_C[8] = PredictorSub8_C;
924 VP8LPredictorsSub_C[9] = PredictorSub9_C;
925 VP8LPredictorsSub_C[10] = PredictorSub10_C;
926 VP8LPredictorsSub_C[11] = PredictorSub11_C;
927 VP8LPredictorsSub_C[12] = PredictorSub12_C;
928 VP8LPredictorsSub_C[13] = PredictorSub13_C;
929 VP8LPredictorsSub_C[14] = PredictorSub0_C; // <- padding security sentinels
930 VP8LPredictorsSub_C[15] = PredictorSub0_C;
931
932 // If defined, use CPUInfo() to overwrite some pointers with faster versions.
933 if (VP8GetCPUInfo != NULL) {
934 #if defined(WEBP_USE_SSE2)
935 if (VP8GetCPUInfo(kSSE2)) {
936 VP8LEncDspInitSSE2();
937 #if defined(WEBP_USE_SSE41)
938 if (VP8GetCPUInfo(kSSE4_1)) {
939 VP8LEncDspInitSSE41();
940 }
941 #endif
942 }
943 #endif
944 #if defined(WEBP_USE_MIPS32)
945 if (VP8GetCPUInfo(kMIPS32)) {
946 VP8LEncDspInitMIPS32();
947 }
948 #endif
949 #if defined(WEBP_USE_MIPS_DSP_R2)
950 if (VP8GetCPUInfo(kMIPSdspR2)) {
951 VP8LEncDspInitMIPSdspR2();
952 }
953 #endif
954 #if defined(WEBP_USE_MSA)
955 if (VP8GetCPUInfo(kMSA)) {
956 VP8LEncDspInitMSA();
957 }
958 #endif
959 }
960
961 #if defined(WEBP_USE_NEON)
962 if (WEBP_NEON_OMIT_C_CODE ||
963 (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
964 VP8LEncDspInitNEON();
965 }
966 #endif
967
968 assert(VP8LSubtractGreenFromBlueAndRed != NULL);
969 assert(VP8LTransformColor != NULL);
970 assert(VP8LCollectColorBlueTransforms != NULL);
971 assert(VP8LCollectColorRedTransforms != NULL);
972 assert(VP8LFastLog2Slow != NULL);
973 assert(VP8LFastSLog2Slow != NULL);
974 assert(VP8LExtraCost != NULL);
975 assert(VP8LExtraCostCombined != NULL);
976 assert(VP8LCombinedShannonEntropy != NULL);
977 assert(VP8LGetEntropyUnrefined != NULL);
978 assert(VP8LGetCombinedEntropyUnrefined != NULL);
979 assert(VP8LHistogramAdd != NULL);
980 assert(VP8LVectorMismatch != NULL);
981 assert(VP8LBundleColorMap != NULL);
982 assert(VP8LPredictorsSub[0] != NULL);
983 assert(VP8LPredictorsSub[1] != NULL);
984 assert(VP8LPredictorsSub[2] != NULL);
985 assert(VP8LPredictorsSub[3] != NULL);
986 assert(VP8LPredictorsSub[4] != NULL);
987 assert(VP8LPredictorsSub[5] != NULL);
988 assert(VP8LPredictorsSub[6] != NULL);
989 assert(VP8LPredictorsSub[7] != NULL);
990 assert(VP8LPredictorsSub[8] != NULL);
991 assert(VP8LPredictorsSub[9] != NULL);
992 assert(VP8LPredictorsSub[10] != NULL);
993 assert(VP8LPredictorsSub[11] != NULL);
994 assert(VP8LPredictorsSub[12] != NULL);
995 assert(VP8LPredictorsSub[13] != NULL);
996 assert(VP8LPredictorsSub[14] != NULL);
997 assert(VP8LPredictorsSub[15] != NULL);
998 assert(VP8LPredictorsSub_C[0] != NULL);
999 assert(VP8LPredictorsSub_C[1] != NULL);
1000 assert(VP8LPredictorsSub_C[2] != NULL);
1001 assert(VP8LPredictorsSub_C[3] != NULL);
1002 assert(VP8LPredictorsSub_C[4] != NULL);
1003 assert(VP8LPredictorsSub_C[5] != NULL);
1004 assert(VP8LPredictorsSub_C[6] != NULL);
1005 assert(VP8LPredictorsSub_C[7] != NULL);
1006 assert(VP8LPredictorsSub_C[8] != NULL);
1007 assert(VP8LPredictorsSub_C[9] != NULL);
1008 assert(VP8LPredictorsSub_C[10] != NULL);
1009 assert(VP8LPredictorsSub_C[11] != NULL);
1010 assert(VP8LPredictorsSub_C[12] != NULL);
1011 assert(VP8LPredictorsSub_C[13] != NULL);
1012 assert(VP8LPredictorsSub_C[14] != NULL);
1013 assert(VP8LPredictorsSub_C[15] != NULL);
1014
1015 lossless_enc_last_cpuinfo_used = VP8GetCPUInfo;
1016 }
1017
1018 //------------------------------------------------------------------------------
1019