• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
AddVector_C(const uint32_t * a,const uint32_t * b,uint32_t * out,int size)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 
AddVectorEq_C(const uint32_t * a,uint32_t * out,int size)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 
VP8LHistogramAdd(const VP8LHistogram * const a,const VP8LHistogram * const b,VP8LHistogram * const out)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 
Average2(uint32_t a0,uint32_t a1)700 static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
701   return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
702 }
703 
Average3(uint32_t a0,uint32_t a1,uint32_t a2)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 
Average4(uint32_t a0,uint32_t a1,uint32_t a2,uint32_t a3)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 
Clip255(uint32_t a)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 
AddSubtractComponentFull(int a,int b,int c)722 static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
723   return Clip255(a + b - c);
724 }
725 
ClampedAddSubtractFull(uint32_t c0,uint32_t c1,uint32_t c2)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 
AddSubtractComponentHalf(int a,int b)739 static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {
740   return Clip255(a + (a - b) / 2);
741 }
742 
ClampedAddSubtractHalf(uint32_t c0,uint32_t c1,uint32_t c2)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 
Sub3(int a,int b,int c)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 
Select(uint32_t a,uint32_t b,uint32_t c)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 
Predictor2(uint32_t left,const uint32_t * const top)781 static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {
782   (void)left;
783   return top[0];
784 }
Predictor3(uint32_t left,const uint32_t * const top)785 static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {
786   (void)left;
787   return top[1];
788 }
Predictor4(uint32_t left,const uint32_t * const top)789 static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {
790   (void)left;
791   return top[-1];
792 }
Predictor5(uint32_t left,const uint32_t * const top)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 }
Predictor6(uint32_t left,const uint32_t * const top)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 }
Predictor7(uint32_t left,const uint32_t * const top)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 }
Predictor8(uint32_t left,const uint32_t * const top)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 }
Predictor9(uint32_t left,const uint32_t * const top)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 }
Predictor10(uint32_t left,const uint32_t * const top)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 }
Predictor11(uint32_t left,const uint32_t * const top)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 }
Predictor12(uint32_t left,const uint32_t * const top)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 }
Predictor13(uint32_t left,const uint32_t * const top)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 
PredictorSub0_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)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 
PredictorSub1_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)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 
WEBP_DSP_INIT_FUNC(VP8LEncDspInit)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