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 
WEBP_DSP_INIT_FUNC(VP8LEncDspInit)866 WEBP_DSP_INIT_FUNC(VP8LEncDspInit) {
867   VP8LDspInit();
868 
869 #if !WEBP_NEON_OMIT_C_CODE
870   VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C;
871 
872   VP8LTransformColor = VP8LTransformColor_C;
873 #endif
874 
875   VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C;
876   VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C;
877 
878   VP8LFastLog2Slow = FastLog2Slow_C;
879   VP8LFastSLog2Slow = FastSLog2Slow_C;
880 
881   VP8LExtraCost = ExtraCost_C;
882   VP8LExtraCostCombined = ExtraCostCombined_C;
883   VP8LCombinedShannonEntropy = CombinedShannonEntropy_C;
884 
885   VP8LGetEntropyUnrefined = GetEntropyUnrefined_C;
886   VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C;
887 
888   VP8LHistogramAdd = HistogramAdd_C;
889 
890   VP8LVectorMismatch = VectorMismatch_C;
891   VP8LBundleColorMap = VP8LBundleColorMap_C;
892 
893   VP8LPredictorsSub[0] = PredictorSub0_C;
894   VP8LPredictorsSub[1] = PredictorSub1_C;
895   VP8LPredictorsSub[2] = PredictorSub2_C;
896   VP8LPredictorsSub[3] = PredictorSub3_C;
897   VP8LPredictorsSub[4] = PredictorSub4_C;
898   VP8LPredictorsSub[5] = PredictorSub5_C;
899   VP8LPredictorsSub[6] = PredictorSub6_C;
900   VP8LPredictorsSub[7] = PredictorSub7_C;
901   VP8LPredictorsSub[8] = PredictorSub8_C;
902   VP8LPredictorsSub[9] = PredictorSub9_C;
903   VP8LPredictorsSub[10] = PredictorSub10_C;
904   VP8LPredictorsSub[11] = PredictorSub11_C;
905   VP8LPredictorsSub[12] = PredictorSub12_C;
906   VP8LPredictorsSub[13] = PredictorSub13_C;
907   VP8LPredictorsSub[14] = PredictorSub0_C;  // <- padding security sentinels
908   VP8LPredictorsSub[15] = PredictorSub0_C;
909 
910   VP8LPredictorsSub_C[0] = PredictorSub0_C;
911   VP8LPredictorsSub_C[1] = PredictorSub1_C;
912   VP8LPredictorsSub_C[2] = PredictorSub2_C;
913   VP8LPredictorsSub_C[3] = PredictorSub3_C;
914   VP8LPredictorsSub_C[4] = PredictorSub4_C;
915   VP8LPredictorsSub_C[5] = PredictorSub5_C;
916   VP8LPredictorsSub_C[6] = PredictorSub6_C;
917   VP8LPredictorsSub_C[7] = PredictorSub7_C;
918   VP8LPredictorsSub_C[8] = PredictorSub8_C;
919   VP8LPredictorsSub_C[9] = PredictorSub9_C;
920   VP8LPredictorsSub_C[10] = PredictorSub10_C;
921   VP8LPredictorsSub_C[11] = PredictorSub11_C;
922   VP8LPredictorsSub_C[12] = PredictorSub12_C;
923   VP8LPredictorsSub_C[13] = PredictorSub13_C;
924   VP8LPredictorsSub_C[14] = PredictorSub0_C;  // <- padding security sentinels
925   VP8LPredictorsSub_C[15] = PredictorSub0_C;
926 
927   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
928   if (VP8GetCPUInfo != NULL) {
929 #if defined(WEBP_USE_SSE2)
930     if (VP8GetCPUInfo(kSSE2)) {
931       VP8LEncDspInitSSE2();
932 #if defined(WEBP_USE_SSE41)
933       if (VP8GetCPUInfo(kSSE4_1)) {
934         VP8LEncDspInitSSE41();
935       }
936 #endif
937     }
938 #endif
939 #if defined(WEBP_USE_MIPS32)
940     if (VP8GetCPUInfo(kMIPS32)) {
941       VP8LEncDspInitMIPS32();
942     }
943 #endif
944 #if defined(WEBP_USE_MIPS_DSP_R2)
945     if (VP8GetCPUInfo(kMIPSdspR2)) {
946       VP8LEncDspInitMIPSdspR2();
947     }
948 #endif
949 #if defined(WEBP_USE_MSA)
950     if (VP8GetCPUInfo(kMSA)) {
951       VP8LEncDspInitMSA();
952     }
953 #endif
954   }
955 
956 #if defined(WEBP_USE_NEON)
957   if (WEBP_NEON_OMIT_C_CODE ||
958       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
959     VP8LEncDspInitNEON();
960   }
961 #endif
962 
963   assert(VP8LSubtractGreenFromBlueAndRed != NULL);
964   assert(VP8LTransformColor != NULL);
965   assert(VP8LCollectColorBlueTransforms != NULL);
966   assert(VP8LCollectColorRedTransforms != NULL);
967   assert(VP8LFastLog2Slow != NULL);
968   assert(VP8LFastSLog2Slow != NULL);
969   assert(VP8LExtraCost != NULL);
970   assert(VP8LExtraCostCombined != NULL);
971   assert(VP8LCombinedShannonEntropy != NULL);
972   assert(VP8LGetEntropyUnrefined != NULL);
973   assert(VP8LGetCombinedEntropyUnrefined != NULL);
974   assert(VP8LHistogramAdd != NULL);
975   assert(VP8LVectorMismatch != NULL);
976   assert(VP8LBundleColorMap != NULL);
977   assert(VP8LPredictorsSub[0] != NULL);
978   assert(VP8LPredictorsSub[1] != NULL);
979   assert(VP8LPredictorsSub[2] != NULL);
980   assert(VP8LPredictorsSub[3] != NULL);
981   assert(VP8LPredictorsSub[4] != NULL);
982   assert(VP8LPredictorsSub[5] != NULL);
983   assert(VP8LPredictorsSub[6] != NULL);
984   assert(VP8LPredictorsSub[7] != NULL);
985   assert(VP8LPredictorsSub[8] != NULL);
986   assert(VP8LPredictorsSub[9] != NULL);
987   assert(VP8LPredictorsSub[10] != NULL);
988   assert(VP8LPredictorsSub[11] != NULL);
989   assert(VP8LPredictorsSub[12] != NULL);
990   assert(VP8LPredictorsSub[13] != NULL);
991   assert(VP8LPredictorsSub[14] != NULL);
992   assert(VP8LPredictorsSub[15] != NULL);
993   assert(VP8LPredictorsSub_C[0] != NULL);
994   assert(VP8LPredictorsSub_C[1] != NULL);
995   assert(VP8LPredictorsSub_C[2] != NULL);
996   assert(VP8LPredictorsSub_C[3] != NULL);
997   assert(VP8LPredictorsSub_C[4] != NULL);
998   assert(VP8LPredictorsSub_C[5] != NULL);
999   assert(VP8LPredictorsSub_C[6] != NULL);
1000   assert(VP8LPredictorsSub_C[7] != NULL);
1001   assert(VP8LPredictorsSub_C[8] != NULL);
1002   assert(VP8LPredictorsSub_C[9] != NULL);
1003   assert(VP8LPredictorsSub_C[10] != NULL);
1004   assert(VP8LPredictorsSub_C[11] != NULL);
1005   assert(VP8LPredictorsSub_C[12] != NULL);
1006   assert(VP8LPredictorsSub_C[13] != NULL);
1007   assert(VP8LPredictorsSub_C[14] != NULL);
1008   assert(VP8LPredictorsSub_C[15] != NULL);
1009 }
1010 
1011 //------------------------------------------------------------------------------
1012