| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2011 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 // Cost tables for level and modes | |
| 11 // | |
| 12 // Author: Skal (pascal.massimino@gmail.com) | |
| 13 | |
| 14 #include "./cost.h" | |
| 15 | |
| 16 //------------------------------------------------------------------------------ | |
| 17 // Level cost tables | |
| 18 | |
| 19 // For each given level, the following table gives the pattern of contexts to | |
| 20 // use for coding it (in [][0]) as well as the bit value to use for each | |
| 21 // context (in [][1]). | |
| 22 const uint16_t VP8LevelCodes[MAX_VARIABLE_LEVEL][2] = { | |
| 23 {0x001, 0x000}, {0x007, 0x001}, {0x00f, 0x005}, | |
| 24 {0x00f, 0x00d}, {0x033, 0x003}, {0x033, 0x003}, {0x033, 0x023}, | |
| 25 {0x033, 0x023}, {0x033, 0x023}, {0x033, 0x023}, {0x0d3, 0x013}, | |
| 26 {0x0d3, 0x013}, {0x0d3, 0x013}, {0x0d3, 0x013}, {0x0d3, 0x013}, | |
| 27 {0x0d3, 0x013}, {0x0d3, 0x013}, {0x0d3, 0x013}, {0x0d3, 0x093}, | |
| 28 {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, | |
| 29 {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, | |
| 30 {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, | |
| 31 {0x0d3, 0x093}, {0x0d3, 0x093}, {0x0d3, 0x093}, {0x153, 0x053}, | |
| 32 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 33 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 34 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 35 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 36 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 37 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 38 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, | |
| 39 {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x053}, {0x153, 0x153} | |
| 40 }; | |
| 41 | |
| 42 static int VariableLevelCost(int level, const uint8_t probas[NUM_PROBAS]) { | |
| 43 int pattern = VP8LevelCodes[level - 1][0]; | |
| 44 int bits = VP8LevelCodes[level - 1][1]; | |
| 45 int cost = 0; | |
| 46 int i; | |
| 47 for (i = 2; pattern; ++i) { | |
| 48 if (pattern & 1) { | |
| 49 cost += VP8BitCost(bits & 1, probas[i]); | |
| 50 } | |
| 51 bits >>= 1; | |
| 52 pattern >>= 1; | |
| 53 } | |
| 54 return cost; | |
| 55 } | |
| 56 | |
| 57 //------------------------------------------------------------------------------ | |
| 58 // Pre-calc level costs once for all | |
| 59 | |
| 60 void VP8CalculateLevelCosts(VP8EncProba* const proba) { | |
| 61 int ctype, band, ctx; | |
| 62 | |
| 63 if (!proba->dirty_) return; // nothing to do. | |
| 64 | |
| 65 for (ctype = 0; ctype < NUM_TYPES; ++ctype) { | |
| 66 int n; | |
| 67 for (band = 0; band < NUM_BANDS; ++band) { | |
| 68 for (ctx = 0; ctx < NUM_CTX; ++ctx) { | |
| 69 const uint8_t* const p = proba->coeffs_[ctype][band][ctx]; | |
| 70 uint16_t* const table = proba->level_cost_[ctype][band][ctx]; | |
| 71 const int cost0 = (ctx > 0) ? VP8BitCost(1, p[0]) : 0; | |
| 72 const int cost_base = VP8BitCost(1, p[1]) + cost0; | |
| 73 int v; | |
| 74 table[0] = VP8BitCost(0, p[1]) + cost0; | |
| 75 for (v = 1; v <= MAX_VARIABLE_LEVEL; ++v) { | |
| 76 table[v] = cost_base + VariableLevelCost(v, p); | |
| 77 } | |
| 78 // Starting at level 67 and up, the variable part of the cost is | |
| 79 // actually constant. | |
| 80 } | |
| 81 } | |
| 82 for (n = 0; n < 16; ++n) { // replicate bands. We don't need to sentinel. | |
| 83 for (ctx = 0; ctx < NUM_CTX; ++ctx) { | |
| 84 proba->remapped_costs_[ctype][n][ctx] = | |
| 85 proba->level_cost_[ctype][VP8EncBands[n]][ctx]; | |
| 86 } | |
| 87 } | |
| 88 } | |
| 89 proba->dirty_ = 0; | |
| 90 } | |
| 91 | |
| 92 //------------------------------------------------------------------------------ | |
| 93 // Mode cost tables. | |
| 94 | |
| 95 // These are the fixed probabilities (in the coding trees) turned into bit-cost | |
| 96 // by calling VP8BitCost(). | |
| 97 const uint16_t VP8FixedCostsUV[4] = { 302, 984, 439, 642 }; | |
| 98 // note: these values include the fixed VP8BitCost(1, 145) mode selection cost. | |
| 99 const uint16_t VP8FixedCostsI16[4] = { 663, 919, 872, 919 }; | |
| 100 const uint16_t VP8FixedCostsI4[NUM_BMODES][NUM_BMODES][NUM_BMODES] = { | |
| 101 { { 40, 1151, 1723, 1874, 2103, 2019, 1628, 1777, 2226, 2137 }, | |
| 102 { 192, 469, 1296, 1308, 1849, 1794, 1781, 1703, 1713, 1522 }, | |
| 103 { 142, 910, 762, 1684, 1849, 1576, 1460, 1305, 1801, 1657 }, | |
| 104 { 559, 641, 1370, 421, 1182, 1569, 1612, 1725, 863, 1007 }, | |
| 105 { 299, 1059, 1256, 1108, 636, 1068, 1581, 1883, 869, 1142 }, | |
| 106 { 277, 1111, 707, 1362, 1089, 672, 1603, 1541, 1545, 1291 }, | |
| 107 { 214, 781, 1609, 1303, 1632, 2229, 726, 1560, 1713, 918 }, | |
| 108 { 152, 1037, 1046, 1759, 1983, 2174, 1358, 742, 1740, 1390 }, | |
| 109 { 512, 1046, 1420, 753, 752, 1297, 1486, 1613, 460, 1207 }, | |
| 110 { 424, 827, 1362, 719, 1462, 1202, 1199, 1476, 1199, 538 } }, | |
| 111 { { 240, 402, 1134, 1491, 1659, 1505, 1517, 1555, 1979, 2099 }, | |
| 112 { 467, 242, 960, 1232, 1714, 1620, 1834, 1570, 1676, 1391 }, | |
| 113 { 500, 455, 463, 1507, 1699, 1282, 1564, 982, 2114, 2114 }, | |
| 114 { 672, 643, 1372, 331, 1589, 1667, 1453, 1938, 996, 876 }, | |
| 115 { 458, 783, 1037, 911, 738, 968, 1165, 1518, 859, 1033 }, | |
| 116 { 504, 815, 504, 1139, 1219, 719, 1506, 1085, 1268, 1268 }, | |
| 117 { 333, 630, 1445, 1239, 1883, 3672, 799, 1548, 1865, 598 }, | |
| 118 { 399, 644, 746, 1342, 1856, 1350, 1493, 613, 1855, 1015 }, | |
| 119 { 622, 749, 1205, 608, 1066, 1408, 1290, 1406, 546, 971 }, | |
| 120 { 500, 753, 1041, 668, 1230, 1617, 1297, 1425, 1383, 523 } }, | |
| 121 { { 394, 553, 523, 1502, 1536, 981, 1608, 1142, 1666, 2181 }, | |
| 122 { 655, 430, 375, 1411, 1861, 1220, 1677, 1135, 1978, 1553 }, | |
| 123 { 690, 640, 245, 1954, 2070, 1194, 1528, 982, 1972, 2232 }, | |
| 124 { 559, 834, 741, 867, 1131, 980, 1225, 852, 1092, 784 }, | |
| 125 { 690, 875, 516, 959, 673, 894, 1056, 1190, 1528, 1126 }, | |
| 126 { 740, 951, 384, 1277, 1177, 492, 1579, 1155, 1846, 1513 }, | |
| 127 { 323, 775, 1062, 1776, 3062, 1274, 813, 1188, 1372, 655 }, | |
| 128 { 488, 971, 484, 1767, 1515, 1775, 1115, 503, 1539, 1461 }, | |
| 129 { 740, 1006, 998, 709, 851, 1230, 1337, 788, 741, 721 }, | |
| 130 { 522, 1073, 573, 1045, 1346, 887, 1046, 1146, 1203, 697 } }, | |
| 131 { { 105, 864, 1442, 1009, 1934, 1840, 1519, 1920, 1673, 1579 }, | |
| 132 { 534, 305, 1193, 683, 1388, 2164, 1802, 1894, 1264, 1170 }, | |
| 133 { 305, 518, 877, 1108, 1426, 3215, 1425, 1064, 1320, 1242 }, | |
| 134 { 683, 732, 1927, 257, 1493, 2048, 1858, 1552, 1055, 947 }, | |
| 135 { 394, 814, 1024, 660, 959, 1556, 1282, 1289, 893, 1047 }, | |
| 136 { 528, 615, 996, 940, 1201, 635, 1094, 2515, 803, 1358 }, | |
| 137 { 347, 614, 1609, 1187, 3133, 1345, 1007, 1339, 1017, 667 }, | |
| 138 { 218, 740, 878, 1605, 3650, 3650, 1345, 758, 1357, 1617 }, | |
| 139 { 672, 750, 1541, 558, 1257, 1599, 1870, 2135, 402, 1087 }, | |
| 140 { 592, 684, 1161, 430, 1092, 1497, 1475, 1489, 1095, 822 } }, | |
| 141 { { 228, 1056, 1059, 1368, 752, 982, 1512, 1518, 987, 1782 }, | |
| 142 { 494, 514, 818, 942, 965, 892, 1610, 1356, 1048, 1363 }, | |
| 143 { 512, 648, 591, 1042, 761, 991, 1196, 1454, 1309, 1463 }, | |
| 144 { 683, 749, 1043, 676, 841, 1396, 1133, 1138, 654, 939 }, | |
| 145 { 622, 1101, 1126, 994, 361, 1077, 1203, 1318, 877, 1219 }, | |
| 146 { 631, 1068, 857, 1650, 651, 477, 1650, 1419, 828, 1170 }, | |
| 147 { 555, 727, 1068, 1335, 3127, 1339, 820, 1331, 1077, 429 }, | |
| 148 { 504, 879, 624, 1398, 889, 889, 1392, 808, 891, 1406 }, | |
| 149 { 683, 1602, 1289, 977, 578, 983, 1280, 1708, 406, 1122 }, | |
| 150 { 399, 865, 1433, 1070, 1072, 764, 968, 1477, 1223, 678 } }, | |
| 151 { { 333, 760, 935, 1638, 1010, 529, 1646, 1410, 1472, 2219 }, | |
| 152 { 512, 494, 750, 1160, 1215, 610, 1870, 1868, 1628, 1169 }, | |
| 153 { 572, 646, 492, 1934, 1208, 603, 1580, 1099, 1398, 1995 }, | |
| 154 { 786, 789, 942, 581, 1018, 951, 1599, 1207, 731, 768 }, | |
| 155 { 690, 1015, 672, 1078, 582, 504, 1693, 1438, 1108, 2897 }, | |
| 156 { 768, 1267, 571, 2005, 1243, 244, 2881, 1380, 1786, 1453 }, | |
| 157 { 452, 899, 1293, 903, 1311, 3100, 465, 1311, 1319, 813 }, | |
| 158 { 394, 927, 942, 1103, 1358, 1104, 946, 593, 1363, 1109 }, | |
| 159 { 559, 1005, 1007, 1016, 658, 1173, 1021, 1164, 623, 1028 }, | |
| 160 { 564, 796, 632, 1005, 1014, 863, 2316, 1268, 938, 764 } }, | |
| 161 { { 266, 606, 1098, 1228, 1497, 1243, 948, 1030, 1734, 1461 }, | |
| 162 { 366, 585, 901, 1060, 1407, 1247, 876, 1134, 1620, 1054 }, | |
| 163 { 452, 565, 542, 1729, 1479, 1479, 1016, 886, 2938, 1150 }, | |
| 164 { 555, 1088, 1533, 950, 1354, 895, 834, 1019, 1021, 496 }, | |
| 165 { 704, 815, 1193, 971, 973, 640, 1217, 2214, 832, 578 }, | |
| 166 { 672, 1245, 579, 871, 875, 774, 872, 1273, 1027, 949 }, | |
| 167 { 296, 1134, 2050, 1784, 1636, 3425, 442, 1550, 2076, 722 }, | |
| 168 { 342, 982, 1259, 1846, 1848, 1848, 622, 568, 1847, 1052 }, | |
| 169 { 555, 1064, 1304, 828, 746, 1343, 1075, 1329, 1078, 494 }, | |
| 170 { 288, 1167, 1285, 1174, 1639, 1639, 833, 2254, 1304, 509 } }, | |
| 171 { { 342, 719, 767, 1866, 1757, 1270, 1246, 550, 1746, 2151 }, | |
| 172 { 483, 653, 694, 1509, 1459, 1410, 1218, 507, 1914, 1266 }, | |
| 173 { 488, 757, 447, 2979, 1813, 1268, 1654, 539, 1849, 2109 }, | |
| 174 { 522, 1097, 1085, 851, 1365, 1111, 851, 901, 961, 605 }, | |
| 175 { 709, 716, 841, 728, 736, 945, 941, 862, 2845, 1057 }, | |
| 176 { 512, 1323, 500, 1336, 1083, 681, 1342, 717, 1604, 1350 }, | |
| 177 { 452, 1155, 1372, 1900, 1501, 3290, 311, 944, 1919, 922 }, | |
| 178 { 403, 1520, 977, 2132, 1733, 3522, 1076, 276, 3335, 1547 }, | |
| 179 { 559, 1374, 1101, 615, 673, 2462, 974, 795, 984, 984 }, | |
| 180 { 547, 1122, 1062, 812, 1410, 951, 1140, 622, 1268, 651 } }, | |
| 181 { { 165, 982, 1235, 938, 1334, 1366, 1659, 1578, 964, 1612 }, | |
| 182 { 592, 422, 925, 847, 1139, 1112, 1387, 2036, 861, 1041 }, | |
| 183 { 403, 837, 732, 770, 941, 1658, 1250, 809, 1407, 1407 }, | |
| 184 { 896, 874, 1071, 381, 1568, 1722, 1437, 2192, 480, 1035 }, | |
| 185 { 640, 1098, 1012, 1032, 684, 1382, 1581, 2106, 416, 865 }, | |
| 186 { 559, 1005, 819, 914, 710, 770, 1418, 920, 838, 1435 }, | |
| 187 { 415, 1258, 1245, 870, 1278, 3067, 770, 1021, 1287, 522 }, | |
| 188 { 406, 990, 601, 1009, 1265, 1265, 1267, 759, 1017, 1277 }, | |
| 189 { 968, 1182, 1329, 788, 1032, 1292, 1705, 1714, 203, 1403 }, | |
| 190 { 732, 877, 1279, 471, 901, 1161, 1545, 1294, 755, 755 } }, | |
| 191 { { 111, 931, 1378, 1185, 1933, 1648, 1148, 1714, 1873, 1307 }, | |
| 192 { 406, 414, 1030, 1023, 1910, 1404, 1313, 1647, 1509, 793 }, | |
| 193 { 342, 640, 575, 1088, 1241, 1349, 1161, 1350, 1756, 1502 }, | |
| 194 { 559, 766, 1185, 357, 1682, 1428, 1329, 1897, 1219, 802 }, | |
| 195 { 473, 909, 1164, 771, 719, 2508, 1427, 1432, 722, 782 }, | |
| 196 { 342, 892, 785, 1145, 1150, 794, 1296, 1550, 973, 1057 }, | |
| 197 { 208, 1036, 1326, 1343, 1606, 3395, 815, 1455, 1618, 712 }, | |
| 198 { 228, 928, 890, 1046, 3499, 1711, 994, 829, 1720, 1318 }, | |
| 199 { 768, 724, 1058, 636, 991, 1075, 1319, 1324, 616, 825 }, | |
| 200 { 305, 1167, 1358, 899, 1587, 1587, 987, 1988, 1332, 501 } } | |
| 201 }; | |
| 202 | |
| 203 //------------------------------------------------------------------------------ | |
| 204 // helper functions for residuals struct VP8Residual. | |
| 205 | |
| 206 void VP8InitResidual(int first, int coeff_type, | |
| 207 VP8Encoder* const enc, VP8Residual* const res) { | |
| 208 res->coeff_type = coeff_type; | |
| 209 res->prob = enc->proba_.coeffs_[coeff_type]; | |
| 210 res->stats = enc->proba_.stats_[coeff_type]; | |
| 211 res->costs = enc->proba_.remapped_costs_[coeff_type]; | |
| 212 res->first = first; | |
| 213 } | |
| 214 | |
| 215 //------------------------------------------------------------------------------ | |
| 216 // Mode costs | |
| 217 | |
| 218 int VP8GetCostLuma4(VP8EncIterator* const it, const int16_t levels[16]) { | |
| 219 const int x = (it->i4_ & 3), y = (it->i4_ >> 2); | |
| 220 VP8Residual res; | |
| 221 VP8Encoder* const enc = it->enc_; | |
| 222 int R = 0; | |
| 223 int ctx; | |
| 224 | |
| 225 VP8InitResidual(0, 3, enc, &res); | |
| 226 ctx = it->top_nz_[x] + it->left_nz_[y]; | |
| 227 VP8SetResidualCoeffs(levels, &res); | |
| 228 R += VP8GetResidualCost(ctx, &res); | |
| 229 return R; | |
| 230 } | |
| 231 | |
| 232 int VP8GetCostLuma16(VP8EncIterator* const it, const VP8ModeScore* const rd) { | |
| 233 VP8Residual res; | |
| 234 VP8Encoder* const enc = it->enc_; | |
| 235 int x, y; | |
| 236 int R = 0; | |
| 237 | |
| 238 VP8IteratorNzToBytes(it); // re-import the non-zero context | |
| 239 | |
| 240 // DC | |
| 241 VP8InitResidual(0, 1, enc, &res); | |
| 242 VP8SetResidualCoeffs(rd->y_dc_levels, &res); | |
| 243 R += VP8GetResidualCost(it->top_nz_[8] + it->left_nz_[8], &res); | |
| 244 | |
| 245 // AC | |
| 246 VP8InitResidual(1, 0, enc, &res); | |
| 247 for (y = 0; y < 4; ++y) { | |
| 248 for (x = 0; x < 4; ++x) { | |
| 249 const int ctx = it->top_nz_[x] + it->left_nz_[y]; | |
| 250 VP8SetResidualCoeffs(rd->y_ac_levels[x + y * 4], &res); | |
| 251 R += VP8GetResidualCost(ctx, &res); | |
| 252 it->top_nz_[x] = it->left_nz_[y] = (res.last >= 0); | |
| 253 } | |
| 254 } | |
| 255 return R; | |
| 256 } | |
| 257 | |
| 258 int VP8GetCostUV(VP8EncIterator* const it, const VP8ModeScore* const rd) { | |
| 259 VP8Residual res; | |
| 260 VP8Encoder* const enc = it->enc_; | |
| 261 int ch, x, y; | |
| 262 int R = 0; | |
| 263 | |
| 264 VP8IteratorNzToBytes(it); // re-import the non-zero context | |
| 265 | |
| 266 VP8InitResidual(0, 2, enc, &res); | |
| 267 for (ch = 0; ch <= 2; ch += 2) { | |
| 268 for (y = 0; y < 2; ++y) { | |
| 269 for (x = 0; x < 2; ++x) { | |
| 270 const int ctx = it->top_nz_[4 + ch + x] + it->left_nz_[4 + ch + y]; | |
| 271 VP8SetResidualCoeffs(rd->uv_levels[ch * 2 + x + y * 2], &res); | |
| 272 R += VP8GetResidualCost(ctx, &res); | |
| 273 it->top_nz_[4 + ch + x] = it->left_nz_[4 + ch + y] = (res.last >= 0); | |
| 274 } | |
| 275 } | |
| 276 } | |
| 277 return R; | |
| 278 } | |
| 279 | |
| 280 | |
| 281 //------------------------------------------------------------------------------ | |
| 282 // Recording of token probabilities. | |
| 283 | |
| 284 // We keep the table-free variant around for reference, in case. | |
| 285 #define USE_LEVEL_CODE_TABLE | |
| 286 | |
| 287 // Simulate block coding, but only record statistics. | |
| 288 // Note: no need to record the fixed probas. | |
| 289 int VP8RecordCoeffs(int ctx, const VP8Residual* const res) { | |
| 290 int n = res->first; | |
| 291 // should be stats[VP8EncBands[n]], but it's equivalent for n=0 or 1 | |
| 292 proba_t* s = res->stats[n][ctx]; | |
| 293 if (res->last < 0) { | |
| 294 VP8RecordStats(0, s + 0); | |
| 295 return 0; | |
| 296 } | |
| 297 while (n <= res->last) { | |
| 298 int v; | |
| 299 VP8RecordStats(1, s + 0); // order of record doesn't matter | |
| 300 while ((v = res->coeffs[n++]) == 0) { | |
| 301 VP8RecordStats(0, s + 1); | |
| 302 s = res->stats[VP8EncBands[n]][0]; | |
| 303 } | |
| 304 VP8RecordStats(1, s + 1); | |
| 305 if (!VP8RecordStats(2u < (unsigned int)(v + 1), s + 2)) { // v = -1 or 1 | |
| 306 s = res->stats[VP8EncBands[n]][1]; | |
| 307 } else { | |
| 308 v = abs(v); | |
| 309 #if !defined(USE_LEVEL_CODE_TABLE) | |
| 310 if (!VP8RecordStats(v > 4, s + 3)) { | |
| 311 if (VP8RecordStats(v != 2, s + 4)) | |
| 312 VP8RecordStats(v == 4, s + 5); | |
| 313 } else if (!VP8RecordStats(v > 10, s + 6)) { | |
| 314 VP8RecordStats(v > 6, s + 7); | |
| 315 } else if (!VP8RecordStats((v >= 3 + (8 << 2)), s + 8)) { | |
| 316 VP8RecordStats((v >= 3 + (8 << 1)), s + 9); | |
| 317 } else { | |
| 318 VP8RecordStats((v >= 3 + (8 << 3)), s + 10); | |
| 319 } | |
| 320 #else | |
| 321 if (v > MAX_VARIABLE_LEVEL) { | |
| 322 v = MAX_VARIABLE_LEVEL; | |
| 323 } | |
| 324 | |
| 325 { | |
| 326 const int bits = VP8LevelCodes[v - 1][1]; | |
| 327 int pattern = VP8LevelCodes[v - 1][0]; | |
| 328 int i; | |
| 329 for (i = 0; (pattern >>= 1) != 0; ++i) { | |
| 330 const int mask = 2 << i; | |
| 331 if (pattern & 1) VP8RecordStats(!!(bits & mask), s + 3 + i); | |
| 332 } | |
| 333 } | |
| 334 #endif | |
| 335 s = res->stats[VP8EncBands[n]][2]; | |
| 336 } | |
| 337 } | |
| 338 if (n < 16) VP8RecordStats(0, s + 0); | |
| 339 return 1; | |
| 340 } | |
| 341 | |
| 342 //------------------------------------------------------------------------------ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2651883004:
libwebp-0.6.0-rc1 (Closed)
