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)
28const 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
159const 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
226const 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
293const 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
329static 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
355static 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}
384static 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
405void 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
413void 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
433static 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
457static 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
478static 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
503void 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
514static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {
515 return ((int)color_pred * color) >> 5;
516}
517
518static WEBP_INLINE int8_t U32ToS8(uint32_t v) {
519 return (int8_t)(v & 0xff);
520}
521
522void 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
540static 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
548static 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
559void 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
571void 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
587static 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.
598void 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
620static 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
627static 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
640static 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
646static 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
675void 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
705static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {
706 return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);
707}
708
709static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) {
710 return Average2(Average2(a0, a2), a1);
711}
712
713static 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
718static 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
727static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {
728 return Clip255(a + b - c);
729}
730
731static 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
744static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {
745 return Clip255(a + (a - b) / 2);
746}
747
748static 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
766static 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
774static 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
786static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {
787 (void)left;
788 return top[0];
789}
790static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {
791 (void)left;
792 return top[1];
793}
794static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {
795 (void)left;
796 return top[-1];
797}
798static 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}
802static uint32_t Predictor6(uint32_t left, const uint32_t* const top) {
803 const uint32_t pred = Average2(left, top[-1]);
804 return pred;
805}
806static uint32_t Predictor7(uint32_t left, const uint32_t* const top) {
807 const uint32_t pred = Average2(left, top[0]);
808 return pred;
809}
810static 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}
815static 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}
820static 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}
824static 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}
828static 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}
832static 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
839static 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
846static 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
853GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C)
854GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C)
855GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C)
856GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C)
857GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C)
858GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C)
859GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C)
860GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C)
861GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C)
862GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C)
863GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C)
864GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C)
865
866//------------------------------------------------------------------------------
867
868VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed;
869
870VP8LTransformColorFunc VP8LTransformColor;
871
872VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms;
873VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms;
874
875VP8LFastLog2SlowFunc VP8LFastLog2Slow;
876VP8LFastLog2SlowFunc VP8LFastSLog2Slow;
877
878VP8LCostFunc VP8LExtraCost;
879VP8LCostCombinedFunc VP8LExtraCostCombined;
880VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy;
881
882VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined;
883VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined;
884
885VP8LAddVectorFunc VP8LAddVector;
886VP8LAddVectorEqFunc VP8LAddVectorEq;
887
888VP8LVectorMismatchFunc VP8LVectorMismatch;
889VP8LBundleColorMapFunc VP8LBundleColorMap;
890
891VP8LPredictorAddSubFunc VP8LPredictorsSub[16];
892VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16];
893
894extern void VP8LEncDspInitSSE2(void);
895extern void VP8LEncDspInitSSE41(void);
896extern void VP8LEncDspInitNEON(void);
897extern void VP8LEncDspInitMIPS32(void);
898extern void VP8LEncDspInitMIPSdspR2(void);
899extern void VP8LEncDspInitMSA(void);
900
901WEBP_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