| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2014 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 // MIPS version of lossless functions |
| 11 // |
| 12 // Author(s): Djordje Pesut (djordje.pesut@imgtec.com) |
| 13 // Jovan Zelincevic (jovan.zelincevic@imgtec.com) |
| 14 |
| 15 #include "./dsp.h" |
| 16 #include "./lossless.h" |
| 17 |
| 18 #if defined(WEBP_USE_MIPS32) |
| 19 |
| 20 #include <assert.h> |
| 21 #include <math.h> |
| 22 #include <stdlib.h> |
| 23 #include <string.h> |
| 24 |
| 25 #define APPROX_LOG_WITH_CORRECTION_MAX 65536 |
| 26 #define APPROX_LOG_MAX 4096 |
| 27 #define LOG_2_RECIPROCAL 1.44269504088896338700465094007086 |
| 28 |
| 29 static float FastSLog2Slow(uint32_t v) { |
| 30 assert(v >= LOG_LOOKUP_IDX_MAX); |
| 31 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { |
| 32 uint32_t log_cnt, y, correction; |
| 33 const int c24 = 24; |
| 34 const float v_f = (float)v; |
| 35 uint32_t temp; |
| 36 |
| 37 // Xf = 256 = 2^8 |
| 38 // log_cnt is index of leading one in upper 24 bits |
| 39 __asm__ volatile( |
| 40 "clz %[log_cnt], %[v] \n\t" |
| 41 "addiu %[y], $zero, 1 \n\t" |
| 42 "subu %[log_cnt], %[c24], %[log_cnt] \n\t" |
| 43 "sllv %[y], %[y], %[log_cnt] \n\t" |
| 44 "srlv %[temp], %[v], %[log_cnt] \n\t" |
| 45 : [log_cnt]"=&r"(log_cnt), [y]"=&r"(y), |
| 46 [temp]"=r"(temp) |
| 47 : [c24]"r"(c24), [v]"r"(v) |
| 48 ); |
| 49 |
| 50 // vf = (2^log_cnt) * Xf; where y = 2^log_cnt and Xf < 256 |
| 51 // Xf = floor(Xf) * (1 + (v % y) / v) |
| 52 // log2(Xf) = log2(floor(Xf)) + log2(1 + (v % y) / v) |
| 53 // The correction factor: log(1 + d) ~ d; for very small d values, so |
| 54 // log2(1 + (v % y) / v) ~ LOG_2_RECIPROCAL * (v % y)/v |
| 55 // LOG_2_RECIPROCAL ~ 23/16 |
| 56 |
| 57 // (v % y) = (v % 2^log_cnt) = v & (2^log_cnt - 1) |
| 58 correction = (23 * (v & (y - 1))) >> 4; |
| 59 return v_f * (kLog2Table[temp] + log_cnt) + correction; |
| 60 } else { |
| 61 return (float)(LOG_2_RECIPROCAL * v * log((double)v)); |
| 62 } |
| 63 } |
| 64 |
| 65 static float FastLog2Slow(uint32_t v) { |
| 66 assert(v >= LOG_LOOKUP_IDX_MAX); |
| 67 if (v < APPROX_LOG_WITH_CORRECTION_MAX) { |
| 68 uint32_t log_cnt, y; |
| 69 const int c24 = 24; |
| 70 double log_2; |
| 71 uint32_t temp; |
| 72 |
| 73 __asm__ volatile( |
| 74 "clz %[log_cnt], %[v] \n\t" |
| 75 "addiu %[y], $zero, 1 \n\t" |
| 76 "subu %[log_cnt], %[c24], %[log_cnt] \n\t" |
| 77 "sllv %[y], %[y], %[log_cnt] \n\t" |
| 78 "srlv %[temp], %[v], %[log_cnt] \n\t" |
| 79 : [log_cnt]"=&r"(log_cnt), [y]"=&r"(y), |
| 80 [temp]"=r"(temp) |
| 81 : [c24]"r"(c24), [v]"r"(v) |
| 82 ); |
| 83 |
| 84 log_2 = kLog2Table[temp] + log_cnt; |
| 85 if (v >= APPROX_LOG_MAX) { |
| 86 // Since the division is still expensive, add this correction factor only |
| 87 // for large values of 'v'. |
| 88 |
| 89 const uint32_t correction = (23 * (v & (y - 1))) >> 4; |
| 90 log_2 += (double)correction / v; |
| 91 } |
| 92 return (float)log_2; |
| 93 } else { |
| 94 return (float)(LOG_2_RECIPROCAL * log((double)v)); |
| 95 } |
| 96 } |
| 97 |
| 98 // C version of this function: |
| 99 // int i = 0; |
| 100 // int64_t cost = 0; |
| 101 // const uint32_t* pop = &population[4]; |
| 102 // const uint32_t* LoopEnd = &population[length]; |
| 103 // while (pop != LoopEnd) { |
| 104 // ++i; |
| 105 // cost += i * *pop; |
| 106 // cost += i * *(pop + 1); |
| 107 // pop += 2; |
| 108 // } |
| 109 // return (double)cost; |
| 110 static double ExtraCost(const uint32_t* const population, int length) { |
| 111 int i, temp0, temp1; |
| 112 const uint32_t* pop = &population[4]; |
| 113 const uint32_t* const LoopEnd = &population[length]; |
| 114 |
| 115 __asm__ volatile( |
| 116 "mult $zero, $zero \n\t" |
| 117 "xor %[i], %[i], %[i] \n\t" |
| 118 "beq %[pop], %[LoopEnd], 2f \n\t" |
| 119 "1: \n\t" |
| 120 "lw %[temp0], 0(%[pop]) \n\t" |
| 121 "lw %[temp1], 4(%[pop]) \n\t" |
| 122 "addiu %[i], %[i], 1 \n\t" |
| 123 "addiu %[pop], %[pop], 8 \n\t" |
| 124 "madd %[i], %[temp0] \n\t" |
| 125 "madd %[i], %[temp1] \n\t" |
| 126 "bne %[pop], %[LoopEnd], 1b \n\t" |
| 127 "2: \n\t" |
| 128 "mfhi %[temp0] \n\t" |
| 129 "mflo %[temp1] \n\t" |
| 130 : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1), |
| 131 [i]"=&r"(i), [pop]"+r"(pop) |
| 132 : [LoopEnd]"r"(LoopEnd) |
| 133 : "memory", "hi", "lo" |
| 134 ); |
| 135 |
| 136 return (double)((int64_t)temp0 << 32 | temp1); |
| 137 } |
| 138 |
| 139 // C version of this function: |
| 140 // int i = 0; |
| 141 // int64_t cost = 0; |
| 142 // const uint32_t* pX = &X[4]; |
| 143 // const uint32_t* pY = &Y[4]; |
| 144 // const uint32_t* LoopEnd = &X[length]; |
| 145 // while (pX != LoopEnd) { |
| 146 // const uint32_t xy0 = *pX + *pY; |
| 147 // const uint32_t xy1 = *(pX + 1) + *(pY + 1); |
| 148 // ++i; |
| 149 // cost += i * xy0; |
| 150 // cost += i * xy1; |
| 151 // pX += 2; |
| 152 // pY += 2; |
| 153 // } |
| 154 // return (double)cost; |
| 155 static double ExtraCostCombined(const uint32_t* const X, |
| 156 const uint32_t* const Y, int length) { |
| 157 int i, temp0, temp1, temp2, temp3; |
| 158 const uint32_t* pX = &X[4]; |
| 159 const uint32_t* pY = &Y[4]; |
| 160 const uint32_t* const LoopEnd = &X[length]; |
| 161 |
| 162 __asm__ volatile( |
| 163 "mult $zero, $zero \n\t" |
| 164 "xor %[i], %[i], %[i] \n\t" |
| 165 "beq %[pX], %[LoopEnd], 2f \n\t" |
| 166 "1: \n\t" |
| 167 "lw %[temp0], 0(%[pX]) \n\t" |
| 168 "lw %[temp1], 0(%[pY]) \n\t" |
| 169 "lw %[temp2], 4(%[pX]) \n\t" |
| 170 "lw %[temp3], 4(%[pY]) \n\t" |
| 171 "addiu %[i], %[i], 1 \n\t" |
| 172 "addu %[temp0], %[temp0], %[temp1] \n\t" |
| 173 "addu %[temp2], %[temp2], %[temp3] \n\t" |
| 174 "addiu %[pX], %[pX], 8 \n\t" |
| 175 "addiu %[pY], %[pY], 8 \n\t" |
| 176 "madd %[i], %[temp0] \n\t" |
| 177 "madd %[i], %[temp2] \n\t" |
| 178 "bne %[pX], %[LoopEnd], 1b \n\t" |
| 179 "2: \n\t" |
| 180 "mfhi %[temp0] \n\t" |
| 181 "mflo %[temp1] \n\t" |
| 182 : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1), |
| 183 [temp2]"=&r"(temp2), [temp3]"=&r"(temp3), |
| 184 [i]"=&r"(i), [pX]"+r"(pX), [pY]"+r"(pY) |
| 185 : [LoopEnd]"r"(LoopEnd) |
| 186 : "memory", "hi", "lo" |
| 187 ); |
| 188 |
| 189 return (double)((int64_t)temp0 << 32 | temp1); |
| 190 } |
| 191 |
| 192 #define HUFFMAN_COST_PASS \ |
| 193 __asm__ volatile( \ |
| 194 "sll %[temp1], %[temp0], 3 \n\t" \ |
| 195 "addiu %[temp3], %[streak], -3 \n\t" \ |
| 196 "addu %[temp2], %[pstreaks], %[temp1] \n\t" \ |
| 197 "blez %[temp3], 1f \n\t" \ |
| 198 "srl %[temp1], %[temp1], 1 \n\t" \ |
| 199 "addu %[temp3], %[pcnts], %[temp1] \n\t" \ |
| 200 "lw %[temp0], 4(%[temp2]) \n\t" \ |
| 201 "lw %[temp1], 0(%[temp3]) \n\t" \ |
| 202 "addu %[temp0], %[temp0], %[streak] \n\t" \ |
| 203 "addiu %[temp1], %[temp1], 1 \n\t" \ |
| 204 "sw %[temp0], 4(%[temp2]) \n\t" \ |
| 205 "sw %[temp1], 0(%[temp3]) \n\t" \ |
| 206 "b 2f \n\t" \ |
| 207 "1: \n\t" \ |
| 208 "lw %[temp0], 0(%[temp2]) \n\t" \ |
| 209 "addu %[temp0], %[temp0], %[streak] \n\t" \ |
| 210 "sw %[temp0], 0(%[temp2]) \n\t" \ |
| 211 "2: \n\t" \ |
| 212 : [temp1]"=&r"(temp1), [temp2]"=&r"(temp2), \ |
| 213 [temp3]"=&r"(temp3), [temp0]"+r"(temp0) \ |
| 214 : [pstreaks]"r"(pstreaks), [pcnts]"r"(pcnts), \ |
| 215 [streak]"r"(streak) \ |
| 216 : "memory" \ |
| 217 ); |
| 218 |
| 219 // Returns the various RLE counts |
| 220 static VP8LStreaks HuffmanCostCount(const uint32_t* population, int length) { |
| 221 int i; |
| 222 int streak = 0; |
| 223 VP8LStreaks stats; |
| 224 int* const pstreaks = &stats.streaks[0][0]; |
| 225 int* const pcnts = &stats.counts[0]; |
| 226 int temp0, temp1, temp2, temp3; |
| 227 memset(&stats, 0, sizeof(stats)); |
| 228 for (i = 0; i < length - 1; ++i) { |
| 229 ++streak; |
| 230 if (population[i] == population[i + 1]) { |
| 231 continue; |
| 232 } |
| 233 temp0 = (population[i] != 0); |
| 234 HUFFMAN_COST_PASS |
| 235 streak = 0; |
| 236 } |
| 237 ++streak; |
| 238 temp0 = (population[i] != 0); |
| 239 HUFFMAN_COST_PASS |
| 240 |
| 241 return stats; |
| 242 } |
| 243 |
| 244 static VP8LStreaks HuffmanCostCombinedCount(const uint32_t* X, |
| 245 const uint32_t* Y, int length) { |
| 246 int i; |
| 247 int streak = 0; |
| 248 VP8LStreaks stats; |
| 249 int* const pstreaks = &stats.streaks[0][0]; |
| 250 int* const pcnts = &stats.counts[0]; |
| 251 int temp0, temp1, temp2, temp3; |
| 252 memset(&stats, 0, sizeof(stats)); |
| 253 for (i = 0; i < length - 1; ++i) { |
| 254 const uint32_t xy = X[i] + Y[i]; |
| 255 const uint32_t xy_next = X[i + 1] + Y[i + 1]; |
| 256 ++streak; |
| 257 if (xy == xy_next) { |
| 258 continue; |
| 259 } |
| 260 temp0 = (xy != 0); |
| 261 HUFFMAN_COST_PASS |
| 262 streak = 0; |
| 263 } |
| 264 { |
| 265 const uint32_t xy = X[i] + Y[i]; |
| 266 ++streak; |
| 267 temp0 = (xy != 0); |
| 268 HUFFMAN_COST_PASS |
| 269 } |
| 270 |
| 271 return stats; |
| 272 } |
| 273 |
| 274 #define ASM_START \ |
| 275 __asm__ volatile( \ |
| 276 ".set push \n\t" \ |
| 277 ".set at \n\t" \ |
| 278 ".set macro \n\t" \ |
| 279 "1: \n\t" |
| 280 |
| 281 // P2 = P0 + P1 |
| 282 // A..D - offsets |
| 283 // E - temp variable to tell macro |
| 284 // if pointer should be incremented |
| 285 // literal_ and successive histograms could be unaligned |
| 286 // so we must use ulw and usw |
| 287 #define ADD_TO_OUT(A, B, C, D, E, P0, P1, P2) \ |
| 288 "ulw %[temp0], "#A"(%["#P0"]) \n\t" \ |
| 289 "ulw %[temp1], "#B"(%["#P0"]) \n\t" \ |
| 290 "ulw %[temp2], "#C"(%["#P0"]) \n\t" \ |
| 291 "ulw %[temp3], "#D"(%["#P0"]) \n\t" \ |
| 292 "ulw %[temp4], "#A"(%["#P1"]) \n\t" \ |
| 293 "ulw %[temp5], "#B"(%["#P1"]) \n\t" \ |
| 294 "ulw %[temp6], "#C"(%["#P1"]) \n\t" \ |
| 295 "ulw %[temp7], "#D"(%["#P1"]) \n\t" \ |
| 296 "addu %[temp4], %[temp4], %[temp0] \n\t" \ |
| 297 "addu %[temp5], %[temp5], %[temp1] \n\t" \ |
| 298 "addu %[temp6], %[temp6], %[temp2] \n\t" \ |
| 299 "addu %[temp7], %[temp7], %[temp3] \n\t" \ |
| 300 "addiu %["#P0"], %["#P0"], 16 \n\t" \ |
| 301 ".if "#E" == 1 \n\t" \ |
| 302 "addiu %["#P1"], %["#P1"], 16 \n\t" \ |
| 303 ".endif \n\t" \ |
| 304 "usw %[temp4], "#A"(%["#P2"]) \n\t" \ |
| 305 "usw %[temp5], "#B"(%["#P2"]) \n\t" \ |
| 306 "usw %[temp6], "#C"(%["#P2"]) \n\t" \ |
| 307 "usw %[temp7], "#D"(%["#P2"]) \n\t" \ |
| 308 "addiu %["#P2"], %["#P2"], 16 \n\t" \ |
| 309 "bne %["#P0"], %[LoopEnd], 1b \n\t" \ |
| 310 ".set pop \n\t" \ |
| 311 |
| 312 #define ASM_END_COMMON_0 \ |
| 313 : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1), \ |
| 314 [temp2]"=&r"(temp2), [temp3]"=&r"(temp3), \ |
| 315 [temp4]"=&r"(temp4), [temp5]"=&r"(temp5), \ |
| 316 [temp6]"=&r"(temp6), [temp7]"=&r"(temp7), \ |
| 317 [pa]"+r"(pa), [pout]"+r"(pout) |
| 318 |
| 319 #define ASM_END_COMMON_1 \ |
| 320 : [LoopEnd]"r"(LoopEnd) \ |
| 321 : "memory", "at" \ |
| 322 ); |
| 323 |
| 324 #define ASM_END_0 \ |
| 325 ASM_END_COMMON_0 \ |
| 326 , [pb]"+r"(pb) \ |
| 327 ASM_END_COMMON_1 |
| 328 |
| 329 #define ASM_END_1 \ |
| 330 ASM_END_COMMON_0 \ |
| 331 ASM_END_COMMON_1 |
| 332 |
| 333 #define ADD_VECTOR(A, B, OUT, SIZE, EXTRA_SIZE) do { \ |
| 334 const uint32_t* pa = (const uint32_t*)(A); \ |
| 335 const uint32_t* pb = (const uint32_t*)(B); \ |
| 336 uint32_t* pout = (uint32_t*)(OUT); \ |
| 337 const uint32_t* const LoopEnd = pa + (SIZE); \ |
| 338 assert((SIZE) % 4 == 0); \ |
| 339 ASM_START \ |
| 340 ADD_TO_OUT(0, 4, 8, 12, 1, pa, pb, pout) \ |
| 341 ASM_END_0 \ |
| 342 if ((EXTRA_SIZE) > 0) { \ |
| 343 const int last = (EXTRA_SIZE); \ |
| 344 int i; \ |
| 345 for (i = 0; i < last; ++i) pout[i] = pa[i] + pb[i]; \ |
| 346 } \ |
| 347 } while (0) |
| 348 |
| 349 #define ADD_VECTOR_EQ(A, OUT, SIZE, EXTRA_SIZE) do { \ |
| 350 const uint32_t* pa = (const uint32_t*)(A); \ |
| 351 uint32_t* pout = (uint32_t*)(OUT); \ |
| 352 const uint32_t* const LoopEnd = pa + (SIZE); \ |
| 353 assert((SIZE) % 4 == 0); \ |
| 354 ASM_START \ |
| 355 ADD_TO_OUT(0, 4, 8, 12, 0, pa, pout, pout) \ |
| 356 ASM_END_1 \ |
| 357 if ((EXTRA_SIZE) > 0) { \ |
| 358 const int last = (EXTRA_SIZE); \ |
| 359 int i; \ |
| 360 for (i = 0; i < last; ++i) pout[i] += pa[i]; \ |
| 361 } \ |
| 362 } while (0) |
| 363 |
| 364 static void HistogramAdd(const VP8LHistogram* const a, |
| 365 const VP8LHistogram* const b, |
| 366 VP8LHistogram* const out) { |
| 367 uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7; |
| 368 const int extra_cache_size = VP8LHistogramNumCodes(a->palette_code_bits_) |
| 369 - (NUM_LITERAL_CODES + NUM_LENGTH_CODES); |
| 370 assert(a->palette_code_bits_ == b->palette_code_bits_); |
| 371 |
| 372 if (b != out) { |
| 373 ADD_VECTOR(a->literal_, b->literal_, out->literal_, |
| 374 NUM_LITERAL_CODES + NUM_LENGTH_CODES, extra_cache_size); |
| 375 ADD_VECTOR(a->distance_, b->distance_, out->distance_, |
| 376 NUM_DISTANCE_CODES, 0); |
| 377 ADD_VECTOR(a->red_, b->red_, out->red_, NUM_LITERAL_CODES, 0); |
| 378 ADD_VECTOR(a->blue_, b->blue_, out->blue_, NUM_LITERAL_CODES, 0); |
| 379 ADD_VECTOR(a->alpha_, b->alpha_, out->alpha_, NUM_LITERAL_CODES, 0); |
| 380 } else { |
| 381 ADD_VECTOR_EQ(a->literal_, out->literal_, |
| 382 NUM_LITERAL_CODES + NUM_LENGTH_CODES, extra_cache_size); |
| 383 ADD_VECTOR_EQ(a->distance_, out->distance_, NUM_DISTANCE_CODES, 0); |
| 384 ADD_VECTOR_EQ(a->red_, out->red_, NUM_LITERAL_CODES, 0); |
| 385 ADD_VECTOR_EQ(a->blue_, out->blue_, NUM_LITERAL_CODES, 0); |
| 386 ADD_VECTOR_EQ(a->alpha_, out->alpha_, NUM_LITERAL_CODES, 0); |
| 387 } |
| 388 } |
| 389 |
| 390 #undef ADD_VECTOR_EQ |
| 391 #undef ADD_VECTOR |
| 392 #undef ASM_END_1 |
| 393 #undef ASM_END_0 |
| 394 #undef ASM_END_COMMON_1 |
| 395 #undef ASM_END_COMMON_0 |
| 396 #undef ADD_TO_OUT |
| 397 #undef ASM_START |
| 398 |
| 399 #endif // WEBP_USE_MIPS32 |
| 400 |
| 401 //------------------------------------------------------------------------------ |
| 402 // Entry point |
| 403 |
| 404 extern void VP8LDspInitMIPS32(void); |
| 405 |
| 406 void VP8LDspInitMIPS32(void) { |
| 407 #if defined(WEBP_USE_MIPS32) |
| 408 VP8LFastSLog2Slow = FastSLog2Slow; |
| 409 VP8LFastLog2Slow = FastLog2Slow; |
| 410 VP8LExtraCost = ExtraCost; |
| 411 VP8LExtraCostCombined = ExtraCostCombined; |
| 412 VP8LHuffmanCostCount = HuffmanCostCount; |
| 413 VP8LHuffmanCostCombinedCount = HuffmanCostCombinedCount; |
| 414 VP8LHistogramAdd = HistogramAdd; |
| 415 #endif // WEBP_USE_MIPS32 |
| 416 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1178013008:
Use the upstream version of libwebp, v0.4.3. (Closed)
Base URL: https://skia.googlesource.com/skia.git@master