Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/3rdparty/libwebp/src/dsp/lossless_enc.c
16348 views
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 ([email protected])

13
//          Jyrki Alakuijala ([email protected])

14
//          Urvang Joshi ([email protected])

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


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


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}

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


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


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


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


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


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


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


514
static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) {

515
  return ((int)color_pred * color) >> 5;

516
}

517


518
void VP8LTransformColor_C(const VP8LMultipliers* const m, uint32_t* data,

519
                          int num_pixels) {

520
  int i;

521
  for (i = 0; i < num_pixels; ++i) {

522
    const uint32_t argb = data[i];

523
    const uint32_t green = argb >> 8;

524
    const uint32_t red = argb >> 16;

525
    int new_red = red & 0xff;

526
    int new_blue = argb & 0xff;

527
    new_red -= ColorTransformDelta(m->green_to_red_, green);

528
    new_red &= 0xff;

529
    new_blue -= ColorTransformDelta(m->green_to_blue_, green);

530
    new_blue -= ColorTransformDelta(m->red_to_blue_, red);

531
    new_blue &= 0xff;

532
    data[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);

533
  }

534
}

535


536
static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red,

537
                                             uint32_t argb) {

538
  const uint32_t green = argb >> 8;

539
  int new_red = argb >> 16;

540
  new_red -= ColorTransformDelta(green_to_red, green);

541
  return (new_red & 0xff);

542
}

543


544
static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue,

545
                                              uint8_t red_to_blue,

546
                                              uint32_t argb) {

547
  const uint32_t green = argb >> 8;

548
  const uint32_t red = argb >> 16;

549
  uint8_t new_blue = argb;

550
  new_blue -= ColorTransformDelta(green_to_blue, green);

551
  new_blue -= ColorTransformDelta(red_to_blue, red);

552
  return (new_blue & 0xff);

553
}

554


555
void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride,

556
                                     int tile_width, int tile_height,

557
                                     int green_to_red, int histo[]) {

558
  while (tile_height-- > 0) {

559
    int x;

560
    for (x = 0; x < tile_width; ++x) {

561
      ++histo[TransformColorRed(green_to_red, argb[x])];

562
    }

563
    argb += stride;

564
  }

565
}

566


567
void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,

568
                                      int tile_width, int tile_height,

569
                                      int green_to_blue, int red_to_blue,

570
                                      int histo[]) {

571
  while (tile_height-- > 0) {

572
    int x;

573
    for (x = 0; x < tile_width; ++x) {

574
      ++histo[TransformColorBlue(green_to_blue, red_to_blue, argb[x])];

575
    }

576
    argb += stride;

577
  }

578
}

579


580
//------------------------------------------------------------------------------

581


582
static int VectorMismatch_C(const uint32_t* const array1,

583
                            const uint32_t* const array2, int length) {

584
  int match_len = 0;

585


586
  while (match_len < length && array1[match_len] == array2[match_len]) {

587
    ++match_len;

588
  }

589
  return match_len;

590
}

591


592
// Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.

593
void VP8LBundleColorMap_C(const uint8_t* const row, int width, int xbits,

594
                          uint32_t* dst) {

595
  int x;

596
  if (xbits > 0) {

597
    const int bit_depth = 1 << (3 - xbits);

598
    const int mask = (1 << xbits) - 1;

599
    uint32_t code = 0xff000000;

600
    for (x = 0; x < width; ++x) {

601
      const int xsub = x & mask;

602
      if (xsub == 0) {

603
        code = 0xff000000;

604
      }

605
      code |= row[x] << (8 + bit_depth * xsub);

606
      dst[x >> xbits] = code;

607
    }

608
  } else {

609
    for (x = 0; x < width; ++x) dst[x] = 0xff000000 | (row[x] << 8);

610
  }

611
}

612


613
//------------------------------------------------------------------------------

614


615
static double ExtraCost_C(const uint32_t* population, int length) {

616
  int i;

617
  double cost = 0.;

618
  for (i = 2; i < length - 2; ++i) cost += (i >> 1) * population[i + 2];

619
  return cost;

620
}

621


622
static double ExtraCostCombined_C(const uint32_t* X, const uint32_t* Y,

623
                                  int length) {

624
  int i;

625
  double cost = 0.;

626
  for (i = 2; i < length - 2; ++i) {

627
    const int xy = X[i + 2] + Y[i + 2];

628
    cost += (i >> 1) * xy;

629
  }

630
  return cost;

631
}

632


633
//------------------------------------------------------------------------------

634


635
static void HistogramAdd_C(const VP8LHistogram* const a,

636
                           const VP8LHistogram* const b,

637
                           VP8LHistogram* const out) {

638
  int i;

639
  const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);

640
  assert(a->palette_code_bits_ == b->palette_code_bits_);

641
  if (b != out) {

642
    for (i = 0; i < literal_size; ++i) {

643
      out->literal_[i] = a->literal_[i] + b->literal_[i];

644
    }

645
    for (i = 0; i < NUM_DISTANCE_CODES; ++i) {

646
      out->distance_[i] = a->distance_[i] + b->distance_[i];

647
    }

648
    for (i = 0; i < NUM_LITERAL_CODES; ++i) {

649
      out->red_[i] = a->red_[i] + b->red_[i];

650
      out->blue_[i] = a->blue_[i] + b->blue_[i];

651
      out->alpha_[i] = a->alpha_[i] + b->alpha_[i];

652
    }

653
  } else {

654
    for (i = 0; i < literal_size; ++i) {

655
      out->literal_[i] += a->literal_[i];

656
    }

657
    for (i = 0; i < NUM_DISTANCE_CODES; ++i) {

658
      out->distance_[i] += a->distance_[i];

659
    }

660
    for (i = 0; i < NUM_LITERAL_CODES; ++i) {

661
      out->red_[i] += a->red_[i];

662
      out->blue_[i] += a->blue_[i];

663
      out->alpha_[i] += a->alpha_[i];

664
    }

665
  }

666
}

667


668
//------------------------------------------------------------------------------

669
// Image transforms.

670


671
static WEBP_INLINE uint32_t Average2(uint32_t a0, uint32_t a1) {

672
  return (((a0 ^ a1) & 0xfefefefeu) >> 1) + (a0 & a1);

673
}

674


675
static WEBP_INLINE uint32_t Average3(uint32_t a0, uint32_t a1, uint32_t a2) {

676
  return Average2(Average2(a0, a2), a1);

677
}

678


679
static WEBP_INLINE uint32_t Average4(uint32_t a0, uint32_t a1,

680
                                     uint32_t a2, uint32_t a3) {

681
  return Average2(Average2(a0, a1), Average2(a2, a3));

682
}

683


684
static WEBP_INLINE uint32_t Clip255(uint32_t a) {

685
  if (a < 256) {

686
    return a;

687
  }

688
  // return 0, when a is a negative integer.

689
  // return 255, when a is positive.

690
  return ~a >> 24;

691
}

692


693
static WEBP_INLINE int AddSubtractComponentFull(int a, int b, int c) {

694
  return Clip255(a + b - c);

695
}

696


697
static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,

698
                                                   uint32_t c2) {

699
  const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);

700
  const int r = AddSubtractComponentFull((c0 >> 16) & 0xff,

701
                                         (c1 >> 16) & 0xff,

702
                                         (c2 >> 16) & 0xff);

703
  const int g = AddSubtractComponentFull((c0 >> 8) & 0xff,

704
                                         (c1 >> 8) & 0xff,

705
                                         (c2 >> 8) & 0xff);

706
  const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);

707
  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;

708
}

709


710
static WEBP_INLINE int AddSubtractComponentHalf(int a, int b) {

711
  return Clip255(a + (a - b) / 2);

712
}

713


714
static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,

715
                                                   uint32_t c2) {

716
  const uint32_t ave = Average2(c0, c1);

717
  const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24);

718
  const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff);

719
  const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff);

720
  const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff);

721
  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;

722
}

723


724
// gcc-4.9 on ARM generates incorrect code in Select() when Sub3() is inlined.

725
#if defined(__arm__) && \

726
    (LOCAL_GCC_VERSION == 0x409 || LOCAL_GCC_VERSION == 0x408)

727
# define LOCAL_INLINE __attribute__ ((noinline))

728
#else

729
# define LOCAL_INLINE WEBP_INLINE

730
#endif

731


732
static LOCAL_INLINE int Sub3(int a, int b, int c) {

733
  const int pb = b - c;

734
  const int pa = a - c;

735
  return abs(pb) - abs(pa);

736
}

737


738
#undef LOCAL_INLINE

739


740
static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {

741
  const int pa_minus_pb =

742
      Sub3((a >> 24)       , (b >> 24)       , (c >> 24)       ) +

743
      Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +

744
      Sub3((a >>  8) & 0xff, (b >>  8) & 0xff, (c >>  8) & 0xff) +

745
      Sub3((a      ) & 0xff, (b      ) & 0xff, (c      ) & 0xff);

746
  return (pa_minus_pb <= 0) ? a : b;

747
}

748


749
//------------------------------------------------------------------------------

750
// Predictors

751


752
static uint32_t Predictor2(uint32_t left, const uint32_t* const top) {

753
  (void)left;

754
  return top[0];

755
}

756
static uint32_t Predictor3(uint32_t left, const uint32_t* const top) {

757
  (void)left;

758
  return top[1];

759
}

760
static uint32_t Predictor4(uint32_t left, const uint32_t* const top) {

761
  (void)left;

762
  return top[-1];

763
}

764
static uint32_t Predictor5(uint32_t left, const uint32_t* const top) {

765
  const uint32_t pred = Average3(left, top[0], top[1]);

766
  return pred;

767
}

768
static uint32_t Predictor6(uint32_t left, const uint32_t* const top) {

769
  const uint32_t pred = Average2(left, top[-1]);

770
  return pred;

771
}

772
static uint32_t Predictor7(uint32_t left, const uint32_t* const top) {

773
  const uint32_t pred = Average2(left, top[0]);

774
  return pred;

775
}

776
static uint32_t Predictor8(uint32_t left, const uint32_t* const top) {

777
  const uint32_t pred = Average2(top[-1], top[0]);

778
  (void)left;

779
  return pred;

780
}

781
static uint32_t Predictor9(uint32_t left, const uint32_t* const top) {

782
  const uint32_t pred = Average2(top[0], top[1]);

783
  (void)left;

784
  return pred;

785
}

786
static uint32_t Predictor10(uint32_t left, const uint32_t* const top) {

787
  const uint32_t pred = Average4(left, top[-1], top[0], top[1]);

788
  return pred;

789
}

790
static uint32_t Predictor11(uint32_t left, const uint32_t* const top) {

791
  const uint32_t pred = Select(top[0], left, top[-1]);

792
  return pred;

793
}

794
static uint32_t Predictor12(uint32_t left, const uint32_t* const top) {

795
  const uint32_t pred = ClampedAddSubtractFull(left, top[0], top[-1]);

796
  return pred;

797
}

798
static uint32_t Predictor13(uint32_t left, const uint32_t* const top) {

799
  const uint32_t pred = ClampedAddSubtractHalf(left, top[0], top[-1]);

800
  return pred;

801
}

802


803
//------------------------------------------------------------------------------

804


805
static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper,

806
                            int num_pixels, uint32_t* out) {

807
  int i;

808
  for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], ARGB_BLACK);

809
  (void)upper;

810
}

811


812
static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper,

813
                            int num_pixels, uint32_t* out) {

814
  int i;

815
  for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], in[i - 1]);

816
  (void)upper;

817
}

818


819
GENERATE_PREDICTOR_SUB(Predictor2, PredictorSub2_C)

820
GENERATE_PREDICTOR_SUB(Predictor3, PredictorSub3_C)

821
GENERATE_PREDICTOR_SUB(Predictor4, PredictorSub4_C)

822
GENERATE_PREDICTOR_SUB(Predictor5, PredictorSub5_C)

823
GENERATE_PREDICTOR_SUB(Predictor6, PredictorSub6_C)

824
GENERATE_PREDICTOR_SUB(Predictor7, PredictorSub7_C)

825
GENERATE_PREDICTOR_SUB(Predictor8, PredictorSub8_C)

826
GENERATE_PREDICTOR_SUB(Predictor9, PredictorSub9_C)

827
GENERATE_PREDICTOR_SUB(Predictor10, PredictorSub10_C)

828
GENERATE_PREDICTOR_SUB(Predictor11, PredictorSub11_C)

829
GENERATE_PREDICTOR_SUB(Predictor12, PredictorSub12_C)

830
GENERATE_PREDICTOR_SUB(Predictor13, PredictorSub13_C)

831


832
//------------------------------------------------------------------------------

833


834
VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed;

835


836
VP8LTransformColorFunc VP8LTransformColor;

837


838
VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms;

839
VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms;

840


841
VP8LFastLog2SlowFunc VP8LFastLog2Slow;

842
VP8LFastLog2SlowFunc VP8LFastSLog2Slow;

843


844
VP8LCostFunc VP8LExtraCost;

845
VP8LCostCombinedFunc VP8LExtraCostCombined;

846
VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy;

847


848
VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined;

849
VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined;

850


851
VP8LHistogramAddFunc VP8LHistogramAdd;

852


853
VP8LVectorMismatchFunc VP8LVectorMismatch;

854
VP8LBundleColorMapFunc VP8LBundleColorMap;

855


856
VP8LPredictorAddSubFunc VP8LPredictorsSub[16];

857
VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16];

858


859
extern void VP8LEncDspInitSSE2(void);

860
extern void VP8LEncDspInitSSE41(void);

861
extern void VP8LEncDspInitNEON(void);

862
extern void VP8LEncDspInitMIPS32(void);

863
extern void VP8LEncDspInitMIPSdspR2(void);

864
extern void VP8LEncDspInitMSA(void);

865


866
WEBP_DSP_INIT_FUNC(VP8LEncDspInit) {

867
  VP8LDspInit();

868


869
#if !WEBP_NEON_OMIT_C_CODE

870
  VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C;

871


872
  VP8LTransformColor = VP8LTransformColor_C;

873
#endif

874


875
  VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C;

876
  VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C;

877


878
  VP8LFastLog2Slow = FastLog2Slow_C;

879
  VP8LFastSLog2Slow = FastSLog2Slow_C;

880


881
  VP8LExtraCost = ExtraCost_C;

882
  VP8LExtraCostCombined = ExtraCostCombined_C;

883
  VP8LCombinedShannonEntropy = CombinedShannonEntropy_C;

884


885
  VP8LGetEntropyUnrefined = GetEntropyUnrefined_C;

886
  VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C;

887


888
  VP8LHistogramAdd = HistogramAdd_C;

889


890
  VP8LVectorMismatch = VectorMismatch_C;

891
  VP8LBundleColorMap = VP8LBundleColorMap_C;

892


893
  VP8LPredictorsSub[0] = PredictorSub0_C;

894
  VP8LPredictorsSub[1] = PredictorSub1_C;

895
  VP8LPredictorsSub[2] = PredictorSub2_C;

896
  VP8LPredictorsSub[3] = PredictorSub3_C;

897
  VP8LPredictorsSub[4] = PredictorSub4_C;

898
  VP8LPredictorsSub[5] = PredictorSub5_C;

899
  VP8LPredictorsSub[6] = PredictorSub6_C;

900
  VP8LPredictorsSub[7] = PredictorSub7_C;

901
  VP8LPredictorsSub[8] = PredictorSub8_C;

902
  VP8LPredictorsSub[9] = PredictorSub9_C;

903
  VP8LPredictorsSub[10] = PredictorSub10_C;

904
  VP8LPredictorsSub[11] = PredictorSub11_C;

905
  VP8LPredictorsSub[12] = PredictorSub12_C;

906
  VP8LPredictorsSub[13] = PredictorSub13_C;

907
  VP8LPredictorsSub[14] = PredictorSub0_C;  // <- padding security sentinels

908
  VP8LPredictorsSub[15] = PredictorSub0_C;

909


910
  VP8LPredictorsSub_C[0] = PredictorSub0_C;

911
  VP8LPredictorsSub_C[1] = PredictorSub1_C;

912
  VP8LPredictorsSub_C[2] = PredictorSub2_C;

913
  VP8LPredictorsSub_C[3] = PredictorSub3_C;

914
  VP8LPredictorsSub_C[4] = PredictorSub4_C;

915
  VP8LPredictorsSub_C[5] = PredictorSub5_C;

916
  VP8LPredictorsSub_C[6] = PredictorSub6_C;

917
  VP8LPredictorsSub_C[7] = PredictorSub7_C;

918
  VP8LPredictorsSub_C[8] = PredictorSub8_C;

919
  VP8LPredictorsSub_C[9] = PredictorSub9_C;

920
  VP8LPredictorsSub_C[10] = PredictorSub10_C;

921
  VP8LPredictorsSub_C[11] = PredictorSub11_C;

922
  VP8LPredictorsSub_C[12] = PredictorSub12_C;

923
  VP8LPredictorsSub_C[13] = PredictorSub13_C;

924
  VP8LPredictorsSub_C[14] = PredictorSub0_C;  // <- padding security sentinels

925
  VP8LPredictorsSub_C[15] = PredictorSub0_C;

926


927
  // If defined, use CPUInfo() to overwrite some pointers with faster versions.

928
  if (VP8GetCPUInfo != NULL) {

929
#if defined(WEBP_USE_SSE2)

930
    if (VP8GetCPUInfo(kSSE2)) {

931
      VP8LEncDspInitSSE2();

932
#if defined(WEBP_USE_SSE41)

933
      if (VP8GetCPUInfo(kSSE4_1)) {

934
        VP8LEncDspInitSSE41();

935
      }

936
#endif

937
    }

938
#endif

939
#if defined(WEBP_USE_MIPS32)

940
    if (VP8GetCPUInfo(kMIPS32)) {

941
      VP8LEncDspInitMIPS32();

942
    }

943
#endif

944
#if defined(WEBP_USE_MIPS_DSP_R2)

945
    if (VP8GetCPUInfo(kMIPSdspR2)) {

946
      VP8LEncDspInitMIPSdspR2();

947
    }

948
#endif

949
#if defined(WEBP_USE_MSA)

950
    if (VP8GetCPUInfo(kMSA)) {

951
      VP8LEncDspInitMSA();

952
    }

953
#endif

954
  }

955


956
#if defined(WEBP_USE_NEON)

957
  if (WEBP_NEON_OMIT_C_CODE ||

958
      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {

959
    VP8LEncDspInitNEON();

960
  }

961
#endif

962


963
  assert(VP8LSubtractGreenFromBlueAndRed != NULL);

964
  assert(VP8LTransformColor != NULL);

965
  assert(VP8LCollectColorBlueTransforms != NULL);

966
  assert(VP8LCollectColorRedTransforms != NULL);

967
  assert(VP8LFastLog2Slow != NULL);

968
  assert(VP8LFastSLog2Slow != NULL);

969
  assert(VP8LExtraCost != NULL);

970
  assert(VP8LExtraCostCombined != NULL);

971
  assert(VP8LCombinedShannonEntropy != NULL);

972
  assert(VP8LGetEntropyUnrefined != NULL);

973
  assert(VP8LGetCombinedEntropyUnrefined != NULL);

974
  assert(VP8LHistogramAdd != NULL);

975
  assert(VP8LVectorMismatch != NULL);

976
  assert(VP8LBundleColorMap != NULL);

977
  assert(VP8LPredictorsSub[0] != NULL);

978
  assert(VP8LPredictorsSub[1] != NULL);

979
  assert(VP8LPredictorsSub[2] != NULL);

980
  assert(VP8LPredictorsSub[3] != NULL);

981
  assert(VP8LPredictorsSub[4] != NULL);

982
  assert(VP8LPredictorsSub[5] != NULL);

983
  assert(VP8LPredictorsSub[6] != NULL);

984
  assert(VP8LPredictorsSub[7] != NULL);

985
  assert(VP8LPredictorsSub[8] != NULL);

986
  assert(VP8LPredictorsSub[9] != NULL);

987
  assert(VP8LPredictorsSub[10] != NULL);

988
  assert(VP8LPredictorsSub[11] != NULL);

989
  assert(VP8LPredictorsSub[12] != NULL);

990
  assert(VP8LPredictorsSub[13] != NULL);

991
  assert(VP8LPredictorsSub[14] != NULL);

992
  assert(VP8LPredictorsSub[15] != NULL);

993
  assert(VP8LPredictorsSub_C[0] != NULL);

994
  assert(VP8LPredictorsSub_C[1] != NULL);

995
  assert(VP8LPredictorsSub_C[2] != NULL);

996
  assert(VP8LPredictorsSub_C[3] != NULL);

997
  assert(VP8LPredictorsSub_C[4] != NULL);

998
  assert(VP8LPredictorsSub_C[5] != NULL);

999
  assert(VP8LPredictorsSub_C[6] != NULL);

1000
  assert(VP8LPredictorsSub_C[7] != NULL);

1001
  assert(VP8LPredictorsSub_C[8] != NULL);

1002
  assert(VP8LPredictorsSub_C[9] != NULL);

1003
  assert(VP8LPredictorsSub_C[10] != NULL);

1004
  assert(VP8LPredictorsSub_C[11] != NULL);

1005
  assert(VP8LPredictorsSub_C[12] != NULL);

1006
  assert(VP8LPredictorsSub_C[13] != NULL);

1007
  assert(VP8LPredictorsSub_C[14] != NULL);

1008
  assert(VP8LPredictorsSub_C[15] != NULL);

1009
}

1010


1011
//------------------------------------------------------------------------------

1012


1013