lossless_enc.c (35457B)
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 <assert.h> 17 #include <math.h> 18 #include <stdlib.h> 19 #include <string.h> 20 21 #include "src/dsp/cpu.h" 22 #include "src/dsp/dsp.h" 23 #include "src/dsp/lossless.h" 24 #include "src/dsp/lossless_common.h" 25 #include "src/enc/histogram_enc.h" 26 #include "src/utils/utils.h" 27 #include "src/webp/format_constants.h" 28 #include "src/webp/types.h" 29 30 // lookup table for small values of log2(int) * (1 << LOG_2_PRECISION_BITS). 31 // Obtained in Python with: 32 // a = [ str(round((1<<23)*math.log2(i))) if i else "0" for i in range(256)] 33 // print(',\n'.join([' '+','.join(v) 34 // for v in batched([i.rjust(9) for i in a],7)])) 35 const uint32_t kLog2Table[LOG_LOOKUP_IDX_MAX] = { 36 0, 0, 8388608, 13295629, 16777216, 19477745, 21684237, 37 23549800, 25165824, 26591258, 27866353, 29019816, 30072845, 31041538, 38 31938408, 32773374, 33554432, 34288123, 34979866, 35634199, 36254961, 39 36845429, 37408424, 37946388, 38461453, 38955489, 39430146, 39886887, 40 40327016, 40751698, 41161982, 41558811, 41943040, 42315445, 42676731, 41 43027545, 43368474, 43700062, 44022807, 44337167, 44643569, 44942404, 42 45234037, 45518808, 45797032, 46069003, 46334996, 46595268, 46850061, 43 47099600, 47344097, 47583753, 47818754, 48049279, 48275495, 48497560, 44 48715624, 48929828, 49140306, 49347187, 49550590, 49750631, 49947419, 45 50141058, 50331648, 50519283, 50704053, 50886044, 51065339, 51242017, 46 51416153, 51587818, 51757082, 51924012, 52088670, 52251118, 52411415, 47 52569616, 52725775, 52879946, 53032177, 53182516, 53331012, 53477707, 48 53622645, 53765868, 53907416, 54047327, 54185640, 54322389, 54457611, 49 54591338, 54723604, 54854440, 54983876, 55111943, 55238669, 55364082, 50 55488208, 55611074, 55732705, 55853126, 55972361, 56090432, 56207362, 51 56323174, 56437887, 56551524, 56664103, 56775645, 56886168, 56995691, 52 57104232, 57211808, 57318436, 57424133, 57528914, 57632796, 57735795, 53 57837923, 57939198, 58039632, 58139239, 58238033, 58336027, 58433234, 54 58529666, 58625336, 58720256, 58814437, 58907891, 59000628, 59092661, 55 59183999, 59274652, 59364632, 59453947, 59542609, 59630625, 59718006, 56 59804761, 59890898, 59976426, 60061354, 60145690, 60229443, 60312620, 57 60395229, 60477278, 60558775, 60639726, 60720140, 60800023, 60879382, 58 60958224, 61036555, 61114383, 61191714, 61268554, 61344908, 61420785, 59 61496188, 61571124, 61645600, 61719620, 61793189, 61866315, 61939001, 60 62011253, 62083076, 62154476, 62225457, 62296024, 62366182, 62435935, 61 62505289, 62574248, 62642816, 62710997, 62778797, 62846219, 62913267, 62 62979946, 63046260, 63112212, 63177807, 63243048, 63307939, 63372484, 63 63436687, 63500551, 63564080, 63627277, 63690146, 63752690, 63814912, 64 63876816, 63938405, 63999682, 64060650, 64121313, 64181673, 64241734, 65 64301498, 64360969, 64420148, 64479040, 64537646, 64595970, 64654014, 66 64711782, 64769274, 64826495, 64883447, 64940132, 64996553, 65052711, 67 65108611, 65164253, 65219641, 65274776, 65329662, 65384299, 65438691, 68 65492840, 65546747, 65600416, 65653847, 65707044, 65760008, 65812741, 69 65865245, 65917522, 65969575, 66021404, 66073013, 66124403, 66175575, 70 66226531, 66277275, 66327806, 66378127, 66428240, 66478146, 66527847, 71 66577345, 66626641, 66675737, 66724635, 66773336, 66821842, 66870154, 72 66918274, 66966204, 67013944, 67061497 73 }; 74 75 // lookup table for small values of int*log2(int) * (1 << LOG_2_PRECISION_BITS). 76 // Obtained in Python with: 77 // a=[ "%d"%i if i<(1<<32) else "%dull"%i 78 // for i in [ round((1<<LOG_2_PRECISION_BITS)*math.log2(i)*i) if i 79 // else 0 for i in range(256)]] 80 // print(',\n '.join([','.join(v) for v in batched([i.rjust(15) 81 // for i in a],4)])) 82 const uint64_t kSLog2Table[LOG_LOOKUP_IDX_MAX] = { 83 0, 0, 16777216, 39886887, 84 67108864, 97388723, 130105423, 164848600, 85 201326592, 239321324, 278663526, 319217973, 86 360874141, 403539997, 447137711, 491600606, 87 536870912, 582898099, 629637592, 677049776, 88 725099212, 773754010, 822985323, 872766924, 89 923074875, 973887230, 1025183802, 1076945958, 90 1129156447, 1181799249, 1234859451, 1288323135, 91 1342177280, 1396409681, 1451008871, 1505964059, 92 1561265072, 1616902301, 1672866655, 1729149526, 93 1785742744, 1842638548, 1899829557, 1957308741, 94 2015069397, 2073105127, 2131409817, 2189977618ull, 95 2248802933ull, 2307880396ull, 2367204859ull, 2426771383ull, 96 2486575220ull, 2546611805ull, 2606876748ull, 2667365819ull, 97 2728074942ull, 2789000187ull, 2850137762ull, 2911484006ull, 98 2973035382ull, 3034788471ull, 3096739966ull, 3158886666ull, 99 3221225472ull, 3283753383ull, 3346467489ull, 3409364969ull, 100 3472443085ull, 3535699182ull, 3599130679ull, 3662735070ull, 101 3726509920ull, 3790452862ull, 3854561593ull, 3918833872ull, 102 3983267519ull, 4047860410ull, 4112610476ull, 4177515704ull, 103 4242574127ull, 4307783833ull, 4373142952ull, 4438649662ull, 104 4504302186ull, 4570098787ull, 4636037770ull, 4702117480ull, 105 4768336298ull, 4834692645ull, 4901184974ull, 4967811774ull, 106 5034571569ull, 5101462912ull, 5168484389ull, 5235634615ull, 107 5302912235ull, 5370315922ull, 5437844376ull, 5505496324ull, 108 5573270518ull, 5641165737ull, 5709180782ull, 5777314477ull, 109 5845565671ull, 5913933235ull, 5982416059ull, 6051013057ull, 110 6119723161ull, 6188545324ull, 6257478518ull, 6326521733ull, 111 6395673979ull, 6464934282ull, 6534301685ull, 6603775250ull, 112 6673354052ull, 6743037185ull, 6812823756ull, 6882712890ull, 113 6952703725ull, 7022795412ull, 7092987118ull, 7163278025ull, 114 7233667324ull, 7304154222ull, 7374737939ull, 7445417707ull, 115 7516192768ull, 7587062379ull, 7658025806ull, 7729082328ull, 116 7800231234ull, 7871471825ull, 7942803410ull, 8014225311ull, 117 8085736859ull, 8157337394ull, 8229026267ull, 8300802839ull, 118 8372666477ull, 8444616560ull, 8516652476ull, 8588773618ull, 119 8660979393ull, 8733269211ull, 8805642493ull, 8878098667ull, 120 8950637170ull, 9023257446ull, 9095958945ull, 9168741125ull, 121 9241603454ull, 9314545403ull, 9387566451ull, 9460666086ull, 122 9533843800ull, 9607099093ull, 9680431471ull, 9753840445ull, 123 9827325535ull, 9900886263ull, 9974522161ull, 10048232765ull, 124 10122017615ull, 10195876260ull, 10269808253ull, 10343813150ull, 125 10417890516ull, 10492039919ull, 10566260934ull, 10640553138ull, 126 10714916116ull, 10789349456ull, 10863852751ull, 10938425600ull, 127 11013067604ull, 11087778372ull, 11162557513ull, 11237404645ull, 128 11312319387ull, 11387301364ull, 11462350205ull, 11537465541ull, 129 11612647010ull, 11687894253ull, 11763206912ull, 11838584638ull, 130 11914027082ull, 11989533899ull, 12065104750ull, 12140739296ull, 131 12216437206ull, 12292198148ull, 12368021795ull, 12443907826ull, 132 12519855920ull, 12595865759ull, 12671937032ull, 12748069427ull, 133 12824262637ull, 12900516358ull, 12976830290ull, 13053204134ull, 134 13129637595ull, 13206130381ull, 13282682202ull, 13359292772ull, 135 13435961806ull, 13512689025ull, 13589474149ull, 13666316903ull, 136 13743217014ull, 13820174211ull, 13897188225ull, 13974258793ull, 137 14051385649ull, 14128568535ull, 14205807192ull, 14283101363ull, 138 14360450796ull, 14437855239ull, 14515314443ull, 14592828162ull, 139 14670396151ull, 14748018167ull, 14825693972ull, 14903423326ull, 140 14981205995ull, 15059041743ull, 15136930339ull, 15214871554ull, 141 15292865160ull, 15370910930ull, 15449008641ull, 15527158071ull, 142 15605359001ull, 15683611210ull, 15761914485ull, 15840268608ull, 143 15918673369ull, 15997128556ull, 16075633960ull, 16154189373ull, 144 16232794589ull, 16311449405ull, 16390153617ull, 16468907026ull, 145 16547709431ull, 16626560636ull, 16705460444ull, 16784408661ull, 146 16863405094ull, 16942449552ull, 17021541845ull, 17100681785ull 147 }; 148 149 const VP8LPrefixCode kPrefixEncodeCode[PREFIX_LOOKUP_IDX_MAX] = { 150 { 0, 0}, { 0, 0}, { 1, 0}, { 2, 0}, { 3, 0}, { 4, 1}, { 4, 1}, { 5, 1}, 151 { 5, 1}, { 6, 2}, { 6, 2}, { 6, 2}, { 6, 2}, { 7, 2}, { 7, 2}, { 7, 2}, 152 { 7, 2}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, { 8, 3}, 153 { 8, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, { 9, 3}, 154 { 9, 3}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, 155 {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4}, 156 {10, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, 157 {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, {11, 4}, 158 {11, 4}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 159 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 160 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 161 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, 162 {12, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 163 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 164 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 165 {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, {13, 5}, 166 {13, 5}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 167 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 168 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 169 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 170 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 171 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 172 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 173 {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, {14, 6}, 174 {14, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 175 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 176 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 177 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 178 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 179 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 180 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 181 {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, {15, 6}, 182 {15, 6}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 183 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 184 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 185 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 186 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 187 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 188 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 189 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 190 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 191 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 192 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 193 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 194 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 195 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 196 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 197 {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, {16, 7}, 198 {16, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 199 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 200 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 201 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 202 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 203 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 204 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 205 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 206 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 207 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 208 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 209 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 210 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 211 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 212 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 213 {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, 214 }; 215 216 const uint8_t kPrefixEncodeExtraBitsValue[PREFIX_LOOKUP_IDX_MAX] = { 217 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 218 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 219 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 220 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 221 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 222 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 223 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 224 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 225 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 226 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 227 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 228 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 229 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 230 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 231 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 232 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 233 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 234 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 235 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 236 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 237 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 238 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 239 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 240 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 241 127, 242 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 243 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 244 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 245 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 246 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 247 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 248 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 249 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126 250 }; 251 252 static uint64_t FastSLog2Slow_C(uint32_t v) { 253 assert(v >= LOG_LOOKUP_IDX_MAX); 254 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { 255 const uint64_t orig_v = v; 256 uint64_t correction; 257 #if !defined(WEBP_HAVE_SLOW_CLZ_CTZ) 258 // use clz if available 259 const uint64_t log_cnt = BitsLog2Floor(v) - 7; 260 const uint32_t y = 1 << log_cnt; 261 v >>= log_cnt; 262 #else 263 uint64_t log_cnt = 0; 264 uint32_t y = 1; 265 do { 266 ++log_cnt; 267 v = v >> 1; 268 y = y << 1; 269 } while (v >= LOG_LOOKUP_IDX_MAX); 270 #endif 271 // vf = (2^log_cnt) * Xf; where y = 2^log_cnt and Xf < 256 272 // Xf = floor(Xf) * (1 + (v % y) / v) 273 // log2(Xf) = log2(floor(Xf)) + log2(1 + (v % y) / v) 274 // The correction factor: log(1 + d) ~ d; for very small d values, so 275 // log2(1 + (v % y) / v) ~ LOG_2_RECIPROCAL * (v % y)/v 276 correction = LOG_2_RECIPROCAL_FIXED * (orig_v & (y - 1)); 277 return orig_v * (kLog2Table[v] + (log_cnt << LOG_2_PRECISION_BITS)) + 278 correction; 279 } else { 280 return (uint64_t)(LOG_2_RECIPROCAL_FIXED_DOUBLE * v * log((double)v) + .5); 281 } 282 } 283 284 static uint32_t FastLog2Slow_C(uint32_t v) { 285 assert(v >= LOG_LOOKUP_IDX_MAX); 286 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { 287 const uint32_t orig_v = v; 288 uint32_t log_2; 289 #if !defined(WEBP_HAVE_SLOW_CLZ_CTZ) 290 // use clz if available 291 const uint32_t log_cnt = BitsLog2Floor(v) - 7; 292 const uint32_t y = 1 << log_cnt; 293 v >>= log_cnt; 294 #else 295 uint32_t log_cnt = 0; 296 uint32_t y = 1; 297 do { 298 ++log_cnt; 299 v = v >> 1; 300 y = y << 1; 301 } while (v >= LOG_LOOKUP_IDX_MAX); 302 #endif 303 log_2 = kLog2Table[v] + (log_cnt << LOG_2_PRECISION_BITS); 304 if (orig_v >= APPROX_LOG_MAX) { 305 // Since the division is still expensive, add this correction factor only 306 // for large values of 'v'. 307 const uint64_t correction = LOG_2_RECIPROCAL_FIXED * (orig_v & (y - 1)); 308 log_2 += (uint32_t)DivRound(correction, orig_v); 309 } 310 return log_2; 311 } else { 312 return (uint32_t)(LOG_2_RECIPROCAL_FIXED_DOUBLE * log((double)v) + .5); 313 } 314 } 315 316 //------------------------------------------------------------------------------ 317 // Methods to calculate Entropy (Shannon). 318 319 // Compute the combined Shanon's entropy for distribution {X} and {X+Y} 320 static uint64_t CombinedShannonEntropy_C(const uint32_t X[256], 321 const uint32_t Y[256]) { 322 int i; 323 uint64_t retval = 0; 324 uint32_t sumX = 0, sumXY = 0; 325 for (i = 0; i < 256; ++i) { 326 const uint32_t x = X[i]; 327 if (x != 0) { 328 const uint32_t xy = x + Y[i]; 329 sumX += x; 330 retval += VP8LFastSLog2(x); 331 sumXY += xy; 332 retval += VP8LFastSLog2(xy); 333 } else if (Y[i] != 0) { 334 sumXY += Y[i]; 335 retval += VP8LFastSLog2(Y[i]); 336 } 337 } 338 retval = VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY) - retval; 339 return retval; 340 } 341 342 static uint64_t ShannonEntropy_C(const uint32_t* X, int n) { 343 int i; 344 uint64_t retval = 0; 345 uint32_t sumX = 0; 346 for (i = 0; i < n; ++i) { 347 const int x = X[i]; 348 if (x != 0) { 349 sumX += x; 350 retval += VP8LFastSLog2(x); 351 } 352 } 353 retval = VP8LFastSLog2(sumX) - retval; 354 return retval; 355 } 356 357 void VP8LBitEntropyInit(VP8LBitEntropy* const entropy) { 358 entropy->entropy = 0; 359 entropy->sum = 0; 360 entropy->nonzeros = 0; 361 entropy->max_val = 0; 362 entropy->nonzero_code = VP8L_NON_TRIVIAL_SYM; 363 } 364 365 void VP8LBitsEntropyUnrefined(const uint32_t* WEBP_RESTRICT const array, int n, 366 VP8LBitEntropy* WEBP_RESTRICT const entropy) { 367 int i; 368 369 VP8LBitEntropyInit(entropy); 370 371 for (i = 0; i < n; ++i) { 372 if (array[i] != 0) { 373 entropy->sum += array[i]; 374 entropy->nonzero_code = i; 375 ++entropy->nonzeros; 376 entropy->entropy += VP8LFastSLog2(array[i]); 377 if (entropy->max_val < array[i]) { 378 entropy->max_val = array[i]; 379 } 380 } 381 } 382 entropy->entropy = VP8LFastSLog2(entropy->sum) - entropy->entropy; 383 } 384 385 static WEBP_INLINE void GetEntropyUnrefinedHelper( 386 uint32_t val, int i, uint32_t* WEBP_RESTRICT const val_prev, 387 int* WEBP_RESTRICT const i_prev, 388 VP8LBitEntropy* WEBP_RESTRICT const bit_entropy, 389 VP8LStreaks* WEBP_RESTRICT const stats) { 390 const int streak = i - *i_prev; 391 392 // Gather info for the bit entropy. 393 if (*val_prev != 0) { 394 bit_entropy->sum += (*val_prev) * streak; 395 bit_entropy->nonzeros += streak; 396 bit_entropy->nonzero_code = *i_prev; 397 bit_entropy->entropy += VP8LFastSLog2(*val_prev) * streak; 398 if (bit_entropy->max_val < *val_prev) { 399 bit_entropy->max_val = *val_prev; 400 } 401 } 402 403 // Gather info for the Huffman cost. 404 stats->counts[*val_prev != 0] += (streak > 3); 405 stats->streaks[*val_prev != 0][(streak > 3)] += streak; 406 407 *val_prev = val; 408 *i_prev = i; 409 } 410 411 static void GetEntropyUnrefined_C( 412 const uint32_t X[], int length, 413 VP8LBitEntropy* WEBP_RESTRICT const bit_entropy, 414 VP8LStreaks* WEBP_RESTRICT const stats) { 415 int i; 416 int i_prev = 0; 417 uint32_t x_prev = X[0]; 418 419 memset(stats, 0, sizeof(*stats)); 420 VP8LBitEntropyInit(bit_entropy); 421 422 for (i = 1; i < length; ++i) { 423 const uint32_t x = X[i]; 424 if (x != x_prev) { 425 GetEntropyUnrefinedHelper(x, i, &x_prev, &i_prev, bit_entropy, stats); 426 } 427 } 428 GetEntropyUnrefinedHelper(0, i, &x_prev, &i_prev, bit_entropy, stats); 429 430 bit_entropy->entropy = VP8LFastSLog2(bit_entropy->sum) - bit_entropy->entropy; 431 } 432 433 static void GetCombinedEntropyUnrefined_C( 434 const uint32_t X[], const uint32_t Y[], int length, 435 VP8LBitEntropy* WEBP_RESTRICT const bit_entropy, 436 VP8LStreaks* WEBP_RESTRICT const stats) { 437 int i = 1; 438 int i_prev = 0; 439 uint32_t xy_prev = X[0] + Y[0]; 440 441 memset(stats, 0, sizeof(*stats)); 442 VP8LBitEntropyInit(bit_entropy); 443 444 for (i = 1; i < length; ++i) { 445 const uint32_t xy = X[i] + Y[i]; 446 if (xy != xy_prev) { 447 GetEntropyUnrefinedHelper(xy, i, &xy_prev, &i_prev, bit_entropy, stats); 448 } 449 } 450 GetEntropyUnrefinedHelper(0, i, &xy_prev, &i_prev, bit_entropy, stats); 451 452 bit_entropy->entropy = VP8LFastSLog2(bit_entropy->sum) - bit_entropy->entropy; 453 } 454 455 //------------------------------------------------------------------------------ 456 457 void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, int num_pixels) { 458 int i; 459 for (i = 0; i < num_pixels; ++i) { 460 const int argb = (int)argb_data[i]; 461 const int green = (argb >> 8) & 0xff; 462 const uint32_t new_r = (((argb >> 16) & 0xff) - green) & 0xff; 463 const uint32_t new_b = (((argb >> 0) & 0xff) - green) & 0xff; 464 argb_data[i] = ((uint32_t)argb & 0xff00ff00u) | (new_r << 16) | new_b; 465 } 466 } 467 468 static WEBP_INLINE int ColorTransformDelta(int8_t color_pred, int8_t color) { 469 return ((int)color_pred * color) >> 5; 470 } 471 472 static WEBP_INLINE int8_t U32ToS8(uint32_t v) { 473 return (int8_t)(v & 0xff); 474 } 475 476 void VP8LTransformColor_C(const VP8LMultipliers* WEBP_RESTRICT const m, 477 uint32_t* WEBP_RESTRICT data, int num_pixels) { 478 int i; 479 for (i = 0; i < num_pixels; ++i) { 480 const uint32_t argb = data[i]; 481 const int8_t green = U32ToS8(argb >> 8); 482 const int8_t red = U32ToS8(argb >> 16); 483 int new_red = red & 0xff; 484 int new_blue = argb & 0xff; 485 new_red -= ColorTransformDelta((int8_t)m->green_to_red, green); 486 new_red &= 0xff; 487 new_blue -= ColorTransformDelta((int8_t)m->green_to_blue, green); 488 new_blue -= ColorTransformDelta((int8_t)m->red_to_blue, red); 489 new_blue &= 0xff; 490 data[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue); 491 } 492 } 493 494 static WEBP_INLINE uint8_t TransformColorRed(uint8_t green_to_red, 495 uint32_t argb) { 496 const int8_t green = U32ToS8(argb >> 8); 497 int new_red = argb >> 16; 498 new_red -= ColorTransformDelta((int8_t)green_to_red, green); 499 return (new_red & 0xff); 500 } 501 502 static WEBP_INLINE uint8_t TransformColorBlue(uint8_t green_to_blue, 503 uint8_t red_to_blue, 504 uint32_t argb) { 505 const int8_t green = U32ToS8(argb >> 8); 506 const int8_t red = U32ToS8(argb >> 16); 507 int new_blue = argb & 0xff; 508 new_blue -= ColorTransformDelta((int8_t)green_to_blue, green); 509 new_blue -= ColorTransformDelta((int8_t)red_to_blue, red); 510 return (new_blue & 0xff); 511 } 512 513 void VP8LCollectColorRedTransforms_C(const uint32_t* WEBP_RESTRICT argb, 514 int stride, 515 int tile_width, int tile_height, 516 int green_to_red, uint32_t histo[]) { 517 while (tile_height-- > 0) { 518 int x; 519 for (x = 0; x < tile_width; ++x) { 520 ++histo[TransformColorRed((uint8_t)green_to_red, argb[x])]; 521 } 522 argb += stride; 523 } 524 } 525 526 void VP8LCollectColorBlueTransforms_C(const uint32_t* WEBP_RESTRICT argb, 527 int stride, 528 int tile_width, int tile_height, 529 int green_to_blue, int red_to_blue, 530 uint32_t histo[]) { 531 while (tile_height-- > 0) { 532 int x; 533 for (x = 0; x < tile_width; ++x) { 534 ++histo[TransformColorBlue((uint8_t)green_to_blue, (uint8_t)red_to_blue, 535 argb[x])]; 536 } 537 argb += stride; 538 } 539 } 540 541 //------------------------------------------------------------------------------ 542 543 static int VectorMismatch_C(const uint32_t* const array1, 544 const uint32_t* const array2, int length) { 545 int match_len = 0; 546 547 while (match_len < length && array1[match_len] == array2[match_len]) { 548 ++match_len; 549 } 550 return match_len; 551 } 552 553 // Bundles multiple (1, 2, 4 or 8) pixels into a single pixel. 554 void VP8LBundleColorMap_C(const uint8_t* WEBP_RESTRICT const row, 555 int width, int xbits, uint32_t* WEBP_RESTRICT dst) { 556 int x; 557 if (xbits > 0) { 558 const int bit_depth = 1 << (3 - xbits); 559 const int mask = (1 << xbits) - 1; 560 uint32_t code = 0xff000000; 561 for (x = 0; x < width; ++x) { 562 const int xsub = x & mask; 563 if (xsub == 0) { 564 code = 0xff000000; 565 } 566 code |= row[x] << (8 + bit_depth * xsub); 567 dst[x >> xbits] = code; 568 } 569 } else { 570 for (x = 0; x < width; ++x) dst[x] = 0xff000000 | (row[x] << 8); 571 } 572 } 573 574 //------------------------------------------------------------------------------ 575 576 static uint32_t ExtraCost_C(const uint32_t* population, int length) { 577 int i; 578 uint32_t cost = population[4] + population[5]; 579 assert(length % 2 == 0); 580 for (i = 2; i < length / 2 - 1; ++i) { 581 cost += i * (population[2 * i + 2] + population[2 * i + 3]); 582 } 583 return cost; 584 } 585 586 //------------------------------------------------------------------------------ 587 588 static void AddVector_C(const uint32_t* WEBP_RESTRICT a, 589 const uint32_t* WEBP_RESTRICT b, 590 uint32_t* WEBP_RESTRICT out, int size) { 591 int i; 592 for (i = 0; i < size; ++i) out[i] = a[i] + b[i]; 593 } 594 595 static void AddVectorEq_C(const uint32_t* WEBP_RESTRICT a, 596 uint32_t* WEBP_RESTRICT out, int size) { 597 int i; 598 for (i = 0; i < size; ++i) out[i] += a[i]; 599 } 600 601 //------------------------------------------------------------------------------ 602 // Image transforms. 603 604 static void PredictorSub0_C(const uint32_t* in, const uint32_t* upper, 605 int num_pixels, uint32_t* WEBP_RESTRICT out) { 606 int i; 607 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], ARGB_BLACK); 608 (void)upper; 609 } 610 611 static void PredictorSub1_C(const uint32_t* in, const uint32_t* upper, 612 int num_pixels, uint32_t* WEBP_RESTRICT out) { 613 int i; 614 for (i = 0; i < num_pixels; ++i) out[i] = VP8LSubPixels(in[i], in[i - 1]); 615 (void)upper; 616 } 617 618 // It subtracts the prediction from the input pixel and stores the residual 619 // in the output pixel. 620 #define GENERATE_PREDICTOR_SUB(PREDICTOR_I) \ 621 static void PredictorSub##PREDICTOR_I##_C(const uint32_t* in, \ 622 const uint32_t* upper, \ 623 int num_pixels, \ 624 uint32_t* WEBP_RESTRICT out) { \ 625 int x; \ 626 assert(upper != NULL); \ 627 for (x = 0; x < num_pixels; ++x) { \ 628 const uint32_t pred = \ 629 VP8LPredictor##PREDICTOR_I##_C(&in[x - 1], upper + x); \ 630 out[x] = VP8LSubPixels(in[x], pred); \ 631 } \ 632 } 633 634 GENERATE_PREDICTOR_SUB(2) 635 GENERATE_PREDICTOR_SUB(3) 636 GENERATE_PREDICTOR_SUB(4) 637 GENERATE_PREDICTOR_SUB(5) 638 GENERATE_PREDICTOR_SUB(6) 639 GENERATE_PREDICTOR_SUB(7) 640 GENERATE_PREDICTOR_SUB(8) 641 GENERATE_PREDICTOR_SUB(9) 642 GENERATE_PREDICTOR_SUB(10) 643 GENERATE_PREDICTOR_SUB(11) 644 GENERATE_PREDICTOR_SUB(12) 645 GENERATE_PREDICTOR_SUB(13) 646 647 //------------------------------------------------------------------------------ 648 649 VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed; 650 VP8LProcessEncBlueAndRedFunc VP8LSubtractGreenFromBlueAndRed_SSE; 651 652 VP8LTransformColorFunc VP8LTransformColor; 653 VP8LTransformColorFunc VP8LTransformColor_SSE; 654 655 VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms; 656 VP8LCollectColorBlueTransformsFunc VP8LCollectColorBlueTransforms_SSE; 657 VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms; 658 VP8LCollectColorRedTransformsFunc VP8LCollectColorRedTransforms_SSE; 659 660 VP8LFastLog2SlowFunc VP8LFastLog2Slow; 661 VP8LFastSLog2SlowFunc VP8LFastSLog2Slow; 662 663 VP8LCostFunc VP8LExtraCost; 664 VP8LCombinedShannonEntropyFunc VP8LCombinedShannonEntropy; 665 VP8LShannonEntropyFunc VP8LShannonEntropy; 666 667 VP8LGetEntropyUnrefinedFunc VP8LGetEntropyUnrefined; 668 VP8LGetCombinedEntropyUnrefinedFunc VP8LGetCombinedEntropyUnrefined; 669 670 VP8LAddVectorFunc VP8LAddVector; 671 VP8LAddVectorEqFunc VP8LAddVectorEq; 672 673 VP8LVectorMismatchFunc VP8LVectorMismatch; 674 VP8LBundleColorMapFunc VP8LBundleColorMap; 675 VP8LBundleColorMapFunc VP8LBundleColorMap_SSE; 676 677 VP8LPredictorAddSubFunc VP8LPredictorsSub[16]; 678 VP8LPredictorAddSubFunc VP8LPredictorsSub_C[16]; 679 VP8LPredictorAddSubFunc VP8LPredictorsSub_SSE[16]; 680 681 extern VP8CPUInfo VP8GetCPUInfo; 682 extern void VP8LEncDspInitSSE2(void); 683 extern void VP8LEncDspInitSSE41(void); 684 extern void VP8LEncDspInitAVX2(void); 685 extern void VP8LEncDspInitNEON(void); 686 extern void VP8LEncDspInitMIPS32(void); 687 extern void VP8LEncDspInitMIPSdspR2(void); 688 extern void VP8LEncDspInitMSA(void); 689 690 WEBP_DSP_INIT_FUNC(VP8LEncDspInit) { 691 VP8LDspInit(); 692 693 #if !WEBP_NEON_OMIT_C_CODE 694 VP8LSubtractGreenFromBlueAndRed = VP8LSubtractGreenFromBlueAndRed_C; 695 696 VP8LTransformColor = VP8LTransformColor_C; 697 #endif 698 699 VP8LCollectColorBlueTransforms = VP8LCollectColorBlueTransforms_C; 700 VP8LCollectColorRedTransforms = VP8LCollectColorRedTransforms_C; 701 702 VP8LFastLog2Slow = FastLog2Slow_C; 703 VP8LFastSLog2Slow = FastSLog2Slow_C; 704 705 VP8LExtraCost = ExtraCost_C; 706 VP8LCombinedShannonEntropy = CombinedShannonEntropy_C; 707 VP8LShannonEntropy = ShannonEntropy_C; 708 709 VP8LGetEntropyUnrefined = GetEntropyUnrefined_C; 710 VP8LGetCombinedEntropyUnrefined = GetCombinedEntropyUnrefined_C; 711 712 VP8LAddVector = AddVector_C; 713 VP8LAddVectorEq = AddVectorEq_C; 714 715 VP8LVectorMismatch = VectorMismatch_C; 716 VP8LBundleColorMap = VP8LBundleColorMap_C; 717 718 VP8LPredictorsSub[0] = PredictorSub0_C; 719 VP8LPredictorsSub[1] = PredictorSub1_C; 720 VP8LPredictorsSub[2] = PredictorSub2_C; 721 VP8LPredictorsSub[3] = PredictorSub3_C; 722 VP8LPredictorsSub[4] = PredictorSub4_C; 723 VP8LPredictorsSub[5] = PredictorSub5_C; 724 VP8LPredictorsSub[6] = PredictorSub6_C; 725 VP8LPredictorsSub[7] = PredictorSub7_C; 726 VP8LPredictorsSub[8] = PredictorSub8_C; 727 VP8LPredictorsSub[9] = PredictorSub9_C; 728 VP8LPredictorsSub[10] = PredictorSub10_C; 729 VP8LPredictorsSub[11] = PredictorSub11_C; 730 VP8LPredictorsSub[12] = PredictorSub12_C; 731 VP8LPredictorsSub[13] = PredictorSub13_C; 732 VP8LPredictorsSub[14] = PredictorSub0_C; // <- padding security sentinels 733 VP8LPredictorsSub[15] = PredictorSub0_C; 734 735 VP8LPredictorsSub_C[0] = PredictorSub0_C; 736 VP8LPredictorsSub_C[1] = PredictorSub1_C; 737 VP8LPredictorsSub_C[2] = PredictorSub2_C; 738 VP8LPredictorsSub_C[3] = PredictorSub3_C; 739 VP8LPredictorsSub_C[4] = PredictorSub4_C; 740 VP8LPredictorsSub_C[5] = PredictorSub5_C; 741 VP8LPredictorsSub_C[6] = PredictorSub6_C; 742 VP8LPredictorsSub_C[7] = PredictorSub7_C; 743 VP8LPredictorsSub_C[8] = PredictorSub8_C; 744 VP8LPredictorsSub_C[9] = PredictorSub9_C; 745 VP8LPredictorsSub_C[10] = PredictorSub10_C; 746 VP8LPredictorsSub_C[11] = PredictorSub11_C; 747 VP8LPredictorsSub_C[12] = PredictorSub12_C; 748 VP8LPredictorsSub_C[13] = PredictorSub13_C; 749 VP8LPredictorsSub_C[14] = PredictorSub0_C; // <- padding security sentinels 750 VP8LPredictorsSub_C[15] = PredictorSub0_C; 751 752 // If defined, use CPUInfo() to overwrite some pointers with faster versions. 753 if (VP8GetCPUInfo != NULL) { 754 #if defined(WEBP_HAVE_SSE2) 755 if (VP8GetCPUInfo(kSSE2)) { 756 VP8LEncDspInitSSE2(); 757 #if defined(WEBP_HAVE_SSE41) 758 if (VP8GetCPUInfo(kSSE4_1)) { 759 VP8LEncDspInitSSE41(); 760 #if defined(WEBP_HAVE_AVX2) 761 if (VP8GetCPUInfo(kAVX2)) { 762 VP8LEncDspInitAVX2(); 763 } 764 #endif 765 } 766 #endif 767 } 768 #endif 769 #if defined(WEBP_USE_MIPS32) 770 if (VP8GetCPUInfo(kMIPS32)) { 771 VP8LEncDspInitMIPS32(); 772 } 773 #endif 774 #if defined(WEBP_USE_MIPS_DSP_R2) 775 if (VP8GetCPUInfo(kMIPSdspR2)) { 776 VP8LEncDspInitMIPSdspR2(); 777 } 778 #endif 779 #if defined(WEBP_USE_MSA) 780 if (VP8GetCPUInfo(kMSA)) { 781 VP8LEncDspInitMSA(); 782 } 783 #endif 784 } 785 786 #if defined(WEBP_HAVE_NEON) 787 if (WEBP_NEON_OMIT_C_CODE || 788 (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) { 789 VP8LEncDspInitNEON(); 790 } 791 #endif 792 793 assert(VP8LSubtractGreenFromBlueAndRed != NULL); 794 assert(VP8LTransformColor != NULL); 795 assert(VP8LCollectColorBlueTransforms != NULL); 796 assert(VP8LCollectColorRedTransforms != NULL); 797 assert(VP8LFastLog2Slow != NULL); 798 assert(VP8LFastSLog2Slow != NULL); 799 assert(VP8LExtraCost != NULL); 800 assert(VP8LCombinedShannonEntropy != NULL); 801 assert(VP8LShannonEntropy != NULL); 802 assert(VP8LGetEntropyUnrefined != NULL); 803 assert(VP8LGetCombinedEntropyUnrefined != NULL); 804 assert(VP8LAddVector != NULL); 805 assert(VP8LAddVectorEq != NULL); 806 assert(VP8LVectorMismatch != NULL); 807 assert(VP8LBundleColorMap != NULL); 808 assert(VP8LPredictorsSub[0] != NULL); 809 assert(VP8LPredictorsSub[1] != NULL); 810 assert(VP8LPredictorsSub[2] != NULL); 811 assert(VP8LPredictorsSub[3] != NULL); 812 assert(VP8LPredictorsSub[4] != NULL); 813 assert(VP8LPredictorsSub[5] != NULL); 814 assert(VP8LPredictorsSub[6] != NULL); 815 assert(VP8LPredictorsSub[7] != NULL); 816 assert(VP8LPredictorsSub[8] != NULL); 817 assert(VP8LPredictorsSub[9] != NULL); 818 assert(VP8LPredictorsSub[10] != NULL); 819 assert(VP8LPredictorsSub[11] != NULL); 820 assert(VP8LPredictorsSub[12] != NULL); 821 assert(VP8LPredictorsSub[13] != NULL); 822 assert(VP8LPredictorsSub[14] != NULL); 823 assert(VP8LPredictorsSub[15] != NULL); 824 assert(VP8LPredictorsSub_C[0] != NULL); 825 assert(VP8LPredictorsSub_C[1] != NULL); 826 assert(VP8LPredictorsSub_C[2] != NULL); 827 assert(VP8LPredictorsSub_C[3] != NULL); 828 assert(VP8LPredictorsSub_C[4] != NULL); 829 assert(VP8LPredictorsSub_C[5] != NULL); 830 assert(VP8LPredictorsSub_C[6] != NULL); 831 assert(VP8LPredictorsSub_C[7] != NULL); 832 assert(VP8LPredictorsSub_C[8] != NULL); 833 assert(VP8LPredictorsSub_C[9] != NULL); 834 assert(VP8LPredictorsSub_C[10] != NULL); 835 assert(VP8LPredictorsSub_C[11] != NULL); 836 assert(VP8LPredictorsSub_C[12] != NULL); 837 assert(VP8LPredictorsSub_C[13] != NULL); 838 assert(VP8LPredictorsSub_C[14] != NULL); 839 assert(VP8LPredictorsSub_C[15] != NULL); 840 } 841 842 //------------------------------------------------------------------------------