• 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 
U32ToS8(uint32_t v)518 static WEBP_INLINE int8_t U32ToS8(uint32_t v) {
519   return (int8_t)(v & 0xff);
520 }
521 
VP8LTransformColor_C(const VP8LMultipliers * const m,uint32_t * data,int num_pixels)522 void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,
523                           int num_pixels) {
524   int i;
525   for (i = 0; i < num_pixels; ++i) {
526     const uint32_t argb = data[i];
527     const int8_t green = U32ToS8(argb >>  8);
528     const int8_t red   = U32ToS8(argb >> 16);
529     int new_red = red & 0xff;
530     int new_blue = argb & 0xff;
531     new_red -= ColorTransformDelta(m->green_to_red_, green);
532     new_red &= 0xff;
533     new_blue -= ColorTransformDelta(m->green_to_blue_, green);
534     new_blue -= ColorTransformDelta(m->red_to_blue_, red);
535     new_blue &= 0xff;
536     data[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
537   }
538 }
539 
TransformColorRed(uint8_t green_to_red,uint32_t argb)540 static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,
541                                              uint32_t argb) {
542   const int8_t green = U32ToS8(argb >> 8);
543   int new_red = argb >> 16;
544   new_red -= ColorTransformDelta(green_to_red, green);
545   return (new_red & 0xff);
546 }
547 
TransformColorBlue(uint8_t green_to_blue,uint8_t red_to_blue,uint32_t argb)548 static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue,
549                                               uint8_t red_to_blue,
550                                               uint32_t argb) {
551   const int8_t green = U32ToS8(argb >>  8);
552   const int8_t red   = U32ToS8(argb >> 16);
553   uint8_t new_blue = argb & 0xff;
554   new_blue -= ColorTransformDelta(green_to_blue, green);
555   new_blue -= ColorTransformDelta(red_to_blue, red);
556   return (new_blue & 0xff);
557 }
558 
VP8LCollectColorRedTransforms_C(const uint32_t * argb,int stride,int tile_width,int tile_height,int green_to_red,int histo[])559 void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride,
560                                      int tile_width, int tile_height,
561                                      int green_to_red, int histo[]) {
562   while (tile_height-- > 0) {
563     int x;
564     for (x = 0; x < tile_width; ++x) {
565       ++histo[TransformColorRed((uint8_t)green_to_red, argb[x])];
566     }
567     argb += stride;
568   }
569 }
570 
VP8LCollectColorBlueTransforms_C(const uint32_t * argb,int stride,int tile_width,int tile_height,int green_to_blue,int red_to_blue,int histo[])571 void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,
572                                       int tile_width, int tile_height,
573                                       int green_to_blue, int red_to_blue,
574                                       int histo[]) {
575   while (tile_height-- > 0) {
576     int x;
577     for (x = 0; x < tile_width; ++x) {
578       ++histo[TransformColorBlue((uint8_t)green_to_blue, (uint8_t)red_to_blue,
579                                  argb[x])];
580     }
581     argb += stride;
582   }
583 }
584 
585 //------------------------------------------------------------------------------
586 
VectorMismatch_C(const uint32_t * const array1,const uint32_t * const array2,int length)587 static int VectorMismatch_C(const uint32_t* const array1,
588                             const uint32_t* const array2, int length) {
589   int match_len = 0;
590 
591   while (match_len < length && array1[match_len] == array2[match_len]) {
592     ++match_len;
593   }
594   return match_len;
595 }
596 
597 // 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)598 void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits,
599                           uint32_t* dst) {
600   int x;
601   if (xbits > 0) {
602     const int bit_depth = 1 << (3 - xbits);
603     const int mask = (1 << xbits) - 1;
604     uint32_t code = 0xff000000;
605     for (x = 0; x < width; ++x) {
606       const int xsub = x & mask;
607       if (xsub == 0) {
608         code = 0xff000000;
609       }
610       code |= row[x] << (8 + bit_depth * xsub);
611       dst[x >> xbits] = code;
612     }
613   } else {
614     for (x = 0; x < width; ++x) dst[x] = 0xff000000 | (row[x] << 8);
615   }
616 }
617 
618 //------------------------------------------------------------------------------
619 
ExtraCost_C(const uint32_t * population,int length)620 static double ExtraCost_C(const uint32_t* population, int length) {
621   int i;
622   double cost = 0.;
623   for (i = 2; i < length - 2; ++i) cost += (i >> 1) * population[i + 2];
624   return cost;
625 }
626 
ExtraCostCombined_C(const uint32_t * X,const uint32_t * Y,int length)627 static double ExtraCostCombined_C(const uint32_t* X, const uint32_t* Y,
628                                   int length) {
629   int i;
630   double cost = 0.;
631   for (i = 2; i < length - 2; ++i) {
632     const int xy = X[i + 2] + Y[i + 2];
633     cost += (i >> 1) * xy;
634   }
635   return cost;
636 }
637 
638 //------------------------------------------------------------------------------
639 
AddVector_C(const uint32_t * a,const uint32_t * b,uint32_t * out,int size)640 static void AddVector_C(const uint32_t* a, const uint32_t* b, uint32_t* out,
641                         int size) {
642   int i;
643   for (i = 0; i < size; ++i) out[i] = a[i] + b[i];
644 }
645 
AddVectorEq_C(const uint32_t * a,uint32_t * out,int size)646 static void AddVectorEq_C(const uint32_t* a, uint32_t* out, int size) {
647   int i;
648   for (i = 0; i < size; ++i) out[i] += a[i];
649 }
650 
651 #define ADD(X, ARG, LEN) do {                                                  \
652   if (a->is_used_[X]) {                                                        \
653     if (b->is_used_[X]) {                                                      \
654       VP8LAddVector(a->ARG, b->ARG, out->ARG, (LEN));                          \
655     } else {                                                                   \
656       memcpy(&out->ARG[0], &a->ARG[0], (LEN) * sizeof(out->ARG[0]));           \
657     }                                                                          \
658   } else if (b->is_used_[X]) {                                                 \
659     memcpy(&out->ARG[0], &b->ARG[0], (LEN) * sizeof(out->ARG[0]));             \
660   } else {                                                                     \
661     memset(&out->ARG[0], 0, (LEN) * sizeof(out->ARG[0]));                      \
662   }                                                                            \
663 } while (0)
664 
665 #define ADD_EQ(X, ARG, LEN) do {                                               \
666   if (a->is_used_[X]) {                                                        \
667     if (out->is_used_[X]) {                                                    \
668       VP8LAddVectorEq(a->ARG, out->ARG, (LEN));                                \
669     } else {                                                                   \
670       memcpy(&out->ARG[0], &a->ARG[0], (LEN) * sizeof(out->ARG[0]));           \
671     }                                                                          \
672   }                                                                            \
673 } while (0)
674 
VP8LHistogramAdd(const VP8LHistogram * const a,const VP8LHistogram * const b,VP8LHistogram * const out)675 void VP8LHistogramAdd(const VP8LHistogram* const a,
676                       const VP8LHistogram* const b, VP8LHistogram* const out) {
677   int i;
678   const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
679   assert(a->palette_code_bits_ == b->palette_code_bits_);
680 
681   if (b != out) {
682     ADD(0, literal_, literal_size);
683     ADD(1, red_, NUM_LITERAL_CODES);
684     ADD(2, blue_, NUM_LITERAL_CODES);
685     ADD(3, alpha_, NUM_LITERAL_CODES);
686     ADD(4, distance_, NUM_DISTANCE_CODES);
687     for (i = 0; i < 5; ++i) {
688       out->is_used_[i] = (a->is_used_[i] | b->is_used_[i]);
689     }
690   } else {
691     ADD_EQ(0, literal_, literal_size);
692     ADD_EQ(1, red_, NUM_LITERAL_CODES);
693     ADD_EQ(2, blue_, NUM_LITERAL_CODES);
694     ADD_EQ(3, alpha_, NUM_LITERAL_CODES);
695     ADD_EQ(4, distance_, NUM_DISTANCE_CODES);
696     for (i = 0; i < 5; ++i) out->is_used_[i] |= a->is_used_[i];
697   }
698 }
699 #undef ADD
700 #undef ADD_EQ
701 
702 //------------------------------------------------------------------------------
703 // Image transforms.
704 
Average2(uint32_t a0,uint32_t a1)705 static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
706   return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
707 }
708 
Average3(uint32_t a0,uint32_t a1,uint32_t a2)709 static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) {
710   return Average2(Average2(a0, a2), a1);
711 }
712 
Average4(uint32_t a0,uint32_t a1,uint32_t a2,uint32_t a3)713 static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,
714                                      uint32_t a2, uint32_t a3) {
715   return Average2(Average2(a0, a1), Average2(a2, a3));
716 }
717 
Clip255(uint32_t a)718 static WEBP_INLINE uint32_t Clip255(uint32_t a) {
719   if (a < 256) {
720     return a;
721   }
722   // return 0, when a is a negative integer.
723   // return 255, when a is positive.
724   return ~a >> 24;
725 }
726 
AddSubtractComponentFull(int a,int b,int c)727 static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
728   return Clip255(a + b - c);
729 }
730 
ClampedAddSubtractFull(uint32_t c0,uint32_t c1,uint32_t c2)731 static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,
732                                                    uint32_t c2) {
733   const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
734   const int r = AddSubtractComponentFull((c0 >> 16) & 0xff,
735                                          (c1 >> 16) & 0xff,
736                                          (c2 >> 16) & 0xff);
737   const int g = AddSubtractComponentFull((c0 >> 8) & 0xff,
738                                          (c1 >> 8) & 0xff,
739                                          (c2 >> 8) & 0xff);
740   const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
741   return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
742 }
743 
AddSubtractComponentHalf(int a,int b)744 static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {
745   return Clip255(a + (a - b) / 2);
746 }
747 
ClampedAddSubtractHalf(uint32_t c0,uint32_t c1,uint32_t c2)748 static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
749                                                    uint32_t c2) {
750   const uint32_t ave = Average2(c0, c1);
751   const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24);
752   const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff);
753   const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff);
754   const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff);
755   return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
756 }
757 
758 // gcc-4.9 on ARM generates incorrect code in Select() when Sub3() is inlined.
759 #if defined(__arm__) && \
760     (LOCAL_GCC_VERSION == 0x409 || LOCAL_GCC_VERSION == 0x408)
761 # define LOCAL_INLINE __attribute__ ((noinline))
762 #else
763 # define LOCAL_INLINE WEBP_INLINE
764 #endif
765 
Sub3(int a,int b,int c)766 static LOCAL_INLINE int Sub3(int a, int b, int c) {
767   const int pb = b - c;
768   const int pa = a - c;
769   return abs(pb) - abs(pa);
770 }
771 
772 #undef LOCAL_INLINE
773 
Select(uint32_t a,uint32_t b,uint32_t c)774 static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
775   const int pa_minus_pb =
776       Sub3((a >> 24)       , (b >> 24)       , (c >> 24)       ) +
777       Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
778       Sub3((a >>  8) & 0xff, (b >>  8) & 0xff, (c >>  8) & 0xff) +
779       Sub3((a      ) & 0xff, (b      ) & 0xff, (c      ) & 0xff);
780   return (pa_minus_pb <= 0) ? a : b;
781 }
782 
783 //------------------------------------------------------------------------------
784 // Predictors
785 
Predictor2(uint32_t left,const uint32_t * const top)786 static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {
787   (void)left;
788   return top[0];
789 }
Predictor3(uint32_t left,const uint32_t * const top)790 static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {
791   (void)left;
792   return top[1];
793 }
Predictor4(uint32_t left,const uint32_t * const top)794 static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {
795   (void)left;
796   return top[-1];
797 }
Predictor5(uint32_t left,const uint32_t * const top)798 static uint32_t Predictor5(uint32_t left, const uint32_t* const top) {
799   const uint32_t pred = Average3(left, top[0], top[1]);
800   return pred;
801 }
Predictor6(uint32_t left,const uint32_t * const top)802 static uint32_t Predictor6(uint32_t left, const uint32_t* const top) {
803   const uint32_t pred = Average2(left, top[-1]);
804   return pred;
805 }
Predictor7(uint32_t left,const uint32_t * const top)806 static uint32_t Predictor7(uint32_t left, const uint32_t* const top) {
807   const uint32_t pred = Average2(left, top[0]);
808   return pred;
809 }
Predictor8(uint32_t left,const uint32_t * const top)810 static uint32_t Predictor8(uint32_t left, const uint32_t* const top) {
811   const uint32_t pred = Average2(top[-1], top[0]);
812   (void)left;
813   return pred;
814 }
Predictor9(uint32_t left,const uint32_t * const top)815 static uint32_t Predictor9(uint32_t left, const uint32_t* const top) {
816   const uint32_t pred = Average2(top[0], top[1]);
817   (void)left;
818   return pred;
819 }
Predictor10(uint32_t left,const uint32_t * const top)820 static uint32_t Predictor10(uint32_t left, const uint32_t* const top) {
821   const uint32_t pred = Average4(left, top[-1], top[0], top[1]);
822   return pred;
823 }
Predictor11(uint32_t left,const uint32_t * const top)824 static uint32_t Predictor11(uint32_t left, const uint32_t* const top) {
825   const uint32_t pred = Select(top[0], left, top[-1]);
826   return pred;
827 }
Predictor12(uint32_t left,const uint32_t * const top)828 static uint32_t Predictor12(uint32_t left, const uint32_t* const top) {
829   const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);
830   return pred;
831 }
Predictor13(uint32_t left,const uint32_t * const top)832 static uint32_t Predictor13(uint32_t left, const uint32_t* const top) {
833   const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);
834   return pred;
835 }
836 
837 //------------------------------------------------------------------------------
838 
PredictorSub0_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)839 static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper,
840                             int num_pixels, uint32_t* out) {
841   int i;
842   for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], ARGB_BLACK);
843   (void)upper;
844 }
845 
PredictorSub1_C(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * out)846 static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper,
847                             int num_pixels, uint32_t* out) {
848   int i;
849   for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], in[i - 1]);
850   (void)upper;
851 }
852 
853 GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C)
854 GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C)
855 GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C)
856 GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C)
857 GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C)
858 GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C)
859 GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C)
860 GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C)
861 GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C)
862 GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C)
863 GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C)
864 GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C)
865 
866 //------------------------------------------------------------------------------
867 
868 VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed;
869 
870 VP8LTransformColorFunc VP8LTransformColor;
871 
872 VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms;
873 VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms;
874 
875 VP8LFastLog2SlowFunc VP8LFastLog2Slow;
876 VP8LFastLog2SlowFunc VP8LFastSLog2Slow;
877 
878 VP8LCostFunc VP8LExtraCost;
879 VP8LCostCombinedFunc VP8LExtraCostCombined;
880 VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy;
881 
882 VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined;
883 VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined;
884 
885 VP8LAddVectorFunc VP8LAddVector;
886 VP8LAddVectorEqFunc VP8LAddVectorEq;
887 
888 VP8LVectorMismatchFunc VP8LVectorMismatch;
889 VP8LBundleColorMapFunc VP8LBundleColorMap;
890 
891 VP8LPredictorAddSubFunc VP8LPredictorsSub[16];
892 VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16];
893 
894 extern void VP8LEncDspInitSSE2(void);
895 extern void VP8LEncDspInitSSE41(void);
896 extern void VP8LEncDspInitNEON(void);
897 extern void VP8LEncDspInitMIPS32(void);
898 extern void VP8LEncDspInitMIPSdspR2(void);
899 extern void VP8LEncDspInitMSA(void);
900 
WEBP_DSP_INIT_FUNC(VP8LEncDspInit)901 WEBP_DSP_INIT_FUNC(VP8LEncDspInit) {
902   VP8LDspInit();
903 
904 #if !WEBP_NEON_OMIT_C_CODE
905   VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C;
906 
907   VP8LTransformColor = VP8LTransformColor_C;
908 #endif
909 
910   VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C;
911   VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C;
912 
913   VP8LFastLog2Slow = FastLog2Slow_C;
914   VP8LFastSLog2Slow = FastSLog2Slow_C;
915 
916   VP8LExtraCost = ExtraCost_C;
917   VP8LExtraCostCombined = ExtraCostCombined_C;
918   VP8LCombinedShannonEntropy = CombinedShannonEntropy_C;
919 
920   VP8LGetEntropyUnrefined = GetEntropyUnrefined_C;
921   VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C;
922 
923   VP8LAddVector = AddVector_C;
924   VP8LAddVectorEq = AddVectorEq_C;
925 
926   VP8LVectorMismatch = VectorMismatch_C;
927   VP8LBundleColorMap = VP8LBundleColorMap_C;
928 
929   VP8LPredictorsSub[0] = PredictorSub0_C;
930   VP8LPredictorsSub[1] = PredictorSub1_C;
931   VP8LPredictorsSub[2] = PredictorSub2_C;
932   VP8LPredictorsSub[3] = PredictorSub3_C;
933   VP8LPredictorsSub[4] = PredictorSub4_C;
934   VP8LPredictorsSub[5] = PredictorSub5_C;
935   VP8LPredictorsSub[6] = PredictorSub6_C;
936   VP8LPredictorsSub[7] = PredictorSub7_C;
937   VP8LPredictorsSub[8] = PredictorSub8_C;
938   VP8LPredictorsSub[9] = PredictorSub9_C;
939   VP8LPredictorsSub[10] = PredictorSub10_C;
940   VP8LPredictorsSub[11] = PredictorSub11_C;
941   VP8LPredictorsSub[12] = PredictorSub12_C;
942   VP8LPredictorsSub[13] = PredictorSub13_C;
943   VP8LPredictorsSub[14] = PredictorSub0_C;  // <- padding security sentinels
944   VP8LPredictorsSub[15] = PredictorSub0_C;
945 
946   VP8LPredictorsSub_C[0] = PredictorSub0_C;
947   VP8LPredictorsSub_C[1] = PredictorSub1_C;
948   VP8LPredictorsSub_C[2] = PredictorSub2_C;
949   VP8LPredictorsSub_C[3] = PredictorSub3_C;
950   VP8LPredictorsSub_C[4] = PredictorSub4_C;
951   VP8LPredictorsSub_C[5] = PredictorSub5_C;
952   VP8LPredictorsSub_C[6] = PredictorSub6_C;
953   VP8LPredictorsSub_C[7] = PredictorSub7_C;
954   VP8LPredictorsSub_C[8] = PredictorSub8_C;
955   VP8LPredictorsSub_C[9] = PredictorSub9_C;
956   VP8LPredictorsSub_C[10] = PredictorSub10_C;
957   VP8LPredictorsSub_C[11] = PredictorSub11_C;
958   VP8LPredictorsSub_C[12] = PredictorSub12_C;
959   VP8LPredictorsSub_C[13] = PredictorSub13_C;
960   VP8LPredictorsSub_C[14] = PredictorSub0_C;  // <- padding security sentinels
961   VP8LPredictorsSub_C[15] = PredictorSub0_C;
962 
963   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
964   if (VP8GetCPUInfo != NULL) {
965 #if defined(WEBP_USE_SSE2)
966     if (VP8GetCPUInfo(kSSE2)) {
967       VP8LEncDspInitSSE2();
968 #if defined(WEBP_USE_SSE41)
969       if (VP8GetCPUInfo(kSSE4_1)) {
970         VP8LEncDspInitSSE41();
971       }
972 #endif
973     }
974 #endif
975 #if defined(WEBP_USE_MIPS32)
976     if (VP8GetCPUInfo(kMIPS32)) {
977       VP8LEncDspInitMIPS32();
978     }
979 #endif
980 #if defined(WEBP_USE_MIPS_DSP_R2)
981     if (VP8GetCPUInfo(kMIPSdspR2)) {
982       VP8LEncDspInitMIPSdspR2();
983     }
984 #endif
985 #if defined(WEBP_USE_MSA)
986     if (VP8GetCPUInfo(kMSA)) {
987       VP8LEncDspInitMSA();
988     }
989 #endif
990   }
991 
992 #if defined(WEBP_USE_NEON)
993   if (WEBP_NEON_OMIT_C_CODE ||
994       (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
995     VP8LEncDspInitNEON();
996   }
997 #endif
998 
999   assert(VP8LSubtractGreenFromBlueAndRed != NULL);
1000   assert(VP8LTransformColor != NULL);
1001   assert(VP8LCollectColorBlueTransforms != NULL);
1002   assert(VP8LCollectColorRedTransforms != NULL);
1003   assert(VP8LFastLog2Slow != NULL);
1004   assert(VP8LFastSLog2Slow != NULL);
1005   assert(VP8LExtraCost != NULL);
1006   assert(VP8LExtraCostCombined != NULL);
1007   assert(VP8LCombinedShannonEntropy != NULL);
1008   assert(VP8LGetEntropyUnrefined != NULL);
1009   assert(VP8LGetCombinedEntropyUnrefined != NULL);
1010   assert(VP8LAddVector != NULL);
1011   assert(VP8LAddVectorEq != NULL);
1012   assert(VP8LVectorMismatch != NULL);
1013   assert(VP8LBundleColorMap != NULL);
1014   assert(VP8LPredictorsSub[0] != NULL);
1015   assert(VP8LPredictorsSub[1] != NULL);
1016   assert(VP8LPredictorsSub[2] != NULL);
1017   assert(VP8LPredictorsSub[3] != NULL);
1018   assert(VP8LPredictorsSub[4] != NULL);
1019   assert(VP8LPredictorsSub[5] != NULL);
1020   assert(VP8LPredictorsSub[6] != NULL);
1021   assert(VP8LPredictorsSub[7] != NULL);
1022   assert(VP8LPredictorsSub[8] != NULL);
1023   assert(VP8LPredictorsSub[9] != NULL);
1024   assert(VP8LPredictorsSub[10] != NULL);
1025   assert(VP8LPredictorsSub[11] != NULL);
1026   assert(VP8LPredictorsSub[12] != NULL);
1027   assert(VP8LPredictorsSub[13] != NULL);
1028   assert(VP8LPredictorsSub[14] != NULL);
1029   assert(VP8LPredictorsSub[15] != NULL);
1030   assert(VP8LPredictorsSub_C[0] != NULL);
1031   assert(VP8LPredictorsSub_C[1] != NULL);
1032   assert(VP8LPredictorsSub_C[2] != NULL);
1033   assert(VP8LPredictorsSub_C[3] != NULL);
1034   assert(VP8LPredictorsSub_C[4] != NULL);
1035   assert(VP8LPredictorsSub_C[5] != NULL);
1036   assert(VP8LPredictorsSub_C[6] != NULL);
1037   assert(VP8LPredictorsSub_C[7] != NULL);
1038   assert(VP8LPredictorsSub_C[8] != NULL);
1039   assert(VP8LPredictorsSub_C[9] != NULL);
1040   assert(VP8LPredictorsSub_C[10] != NULL);
1041   assert(VP8LPredictorsSub_C[11] != NULL);
1042   assert(VP8LPredictorsSub_C[12] != NULL);
1043   assert(VP8LPredictorsSub_C[13] != NULL);
1044   assert(VP8LPredictorsSub_C[14] != NULL);
1045   assert(VP8LPredictorsSub_C[15] != NULL);
1046 }
1047 
1048 //------------------------------------------------------------------------------
1049