Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(5)

Side by Side Diff: src/utils/SkTextureCompressor.cpp

Issue 325733004: Add texture compression utility (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Some more small cleanup Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 /*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "SkTextureCompressor.h"
9
10 #include "SkBitmap.h"
11 #include "SkData.h"
12 #include "SkEndian.h"
13
14 ////////////////////////////////////////////////////////////////////////////////
15 //
16 // Utility Functions
17 //
18 ////////////////////////////////////////////////////////////////////////////////
19
robertphillips 2014/06/09 19:50:18 Maybe SkTAbsDiff in SkTypes.h ?
krajcevski 2014/06/09 20:39:34 Done.
20 template<typename T>
21 static const T absolute_difference(const T& a, const T& b) {
22 return (a > b) ? (a - b) : (b - a);
23 }
24
25 ////////////////////////////////////////////////////////////////////////////////
26 //
27 // LATC compressor
28 //
29 ////////////////////////////////////////////////////////////////////////////////
30
robertphillips 2014/06/09 19:50:18 static const int kLATCPaletteSize = 8; ? // Retur
krajcevski 2014/06/09 20:39:34 Done.
31 static uint16_t compute_error(uint16_t pixel, uint8_t palette[8]) {
32 uint16_t error = 65535;
33 for (int i = 0; i < 8; ++i) {
34 uint16_t diff = absolute_difference(static_cast<uint16_t>(palette[i]), p ixel);
35 error = SkMin32(diff, error);
36 }
37 return error*error;
38 }
39
robertphillips 2014/06/09 19:50:18 // Maybe an overview of the compression algorithm
krajcevski 2014/06/09 20:39:34 Done.
40 static uint64_t compress_latc_block(uint8_t block[16]) {
41 // Just do a simple min/max but choose from which of the
42 // two palettes is better
43 uint8_t maxVal = 0;
44 uint8_t minVal = 255;
45 for (int i = 0; i < 16; ++i) {
46 maxVal = SkMax32(maxVal, block[i]);
47 minVal = SkMin32(minVal, block[i]);
48 }
49
50 // Generate palettes
51 uint8_t palettes[2][8];
52
robertphillips 2014/06/09 19:50:18 // palette 0 is a straight up linear ramp between
krajcevski 2014/06/09 20:39:34 Done.
53 palettes[0][0] = maxVal;
54 palettes[0][1] = minVal;
55 for (int i = 1; i < 7; ++i) {
56 palettes[0][i+1] = ((7-i)*maxVal + i*minVal) / 7;
57 }
58
robertphillips 2014/06/09 19:50:18 // palette 1 is a shorter linear ramp between minV
krajcevski 2014/06/09 20:39:34 The way this algorithm is set up, probably not. In
59 palettes[1][0] = minVal;
60 palettes[1][1] = maxVal;
61 for (int i = 1; i < 5; ++i) {
62 palettes[1][i+1] = ((5-i)*maxVal + i*minVal) / 5;
63 }
64 palettes[1][6] = 0;
65 palettes[1][7] = 255;
robertphillips 2014/06/09 19:50:17 The raster code only ever generates 16 different a
krajcevski 2014/06/09 20:39:34 Yes, probably. I think that investigating better c
66
robertphillips 2014/06/09 19:50:18 error0 & error1 to match palette numbering ?
krajcevski 2014/06/09 20:39:34 Done.
67 // Figure out which of the two is better
68 uint16_t error1 = 0, error2 = 0;
69 for (int i = 0; i < 16; ++i) {
70 uint16_t pixel = static_cast<uint16_t>(block[i]);
71 error1 += compute_error(pixel, palettes[0]);
72 error2 += compute_error(pixel, palettes[1]);
73 }
74 uint8_t *palette = (error1 > error2) ? palettes[1] : palettes[0];
75
76 // Compress the chosen palette
77 uint64_t result = 0;
robertphillips 2014/06/09 19:50:18 Is this jamming the right values in?
krajcevski 2014/06/09 20:39:34 Yes, although I did have to double check.
78 result |= static_cast<uint64_t>(palette[0]);
79 result |= static_cast<uint64_t>(palette[1]) << 8;
80
81 uint64_t indices = 0;
82 for (int i = 15; i >= 0; --i) {
83 uint8_t pixel = block[i];
84
85 uint8_t minError = absolute_difference(pixel, palette[0]);
86 uint8_t minErrorIndex = 0;
robertphillips 2014/06/09 19:50:18 So we essentially do this loop to select the palet
krajcevski 2014/06/09 20:39:34 The palette is selected in the preceding loop. Thi
87 for (int j = 1; j < 8; ++j) {
88 uint8_t error = absolute_difference(pixel, palette[j]);
89 if (error < minError) {
90 minError = error;
91 minErrorIndex = j;
92 }
93 }
94 SkASSERT(minErrorIndex < 8);
95
96 indices <<= 3;
97 indices |= minErrorIndex;
98 }
99 result |= indices << 16;
100
101 // We assume everything is little endian, if it's not then make it so.
102 return SkEndian_SwapLE64(result);
103 }
104
105 static SkData *compress_a8_to_latc(const SkBitmap &bm) {
106 // LATC compressed texels down into square 4x4 blocks
107 static const int kLATCBlockSize = 4;
108
109 // Make sure that our data is well-formed enough to be
110 // considered for LATC compression
111 if (bm.width() == 0 || bm.height() == 0 ||
112 (bm.width() % kLATCBlockSize) != 0 ||
113 (bm.height() % kLATCBlockSize) != 0 ||
114 (bm.config() != SkBitmap::kA8_Config)) {
115 return NULL;
116 }
117
118 // The LATC format is 64 bits per 4x4 block.
119 static const int kLATCEncodedBlockSize = 8;
120
121 int blocksX = bm.width() / kLATCBlockSize;
122 int blocksY = bm.height() / kLATCBlockSize;
123
124 int compressedDataSize = blocksX * blocksY * kLATCEncodedBlockSize;
125 uint64_t* dst = reinterpret_cast<uint64_t*>(sk_malloc_throw(compressedDataSi ze));
126
127 uint8_t block[16];
128 const uint8_t* row = reinterpret_cast<const uint8_t*>(bm.getPixels());
129 uint64_t* encPtr = dst;
130 for (int y = 0; y < blocksY; ++y) {
131 for (int x = 0; x < blocksX; ++x) {
132 memcpy(block, row + (kLATCBlockSize * x), 4);
133 memcpy(block + 4, row + bm.rowBytes() + (kLATCBlockSize * x), 4);
134 memcpy(block + 8, row + 2*bm.rowBytes() + (kLATCBlockSize * x), 4);
135 memcpy(block + 12, row + 3*bm.rowBytes() + (kLATCBlockSize * x), 4);
136
137 *encPtr = compress_latc_block(block);
138 ++encPtr;
139 }
140 row += kLATCBlockSize * bm.rowBytes();
141 }
142
143 return SkData::NewFromMalloc(dst, compressedDataSize);
144 }
145
146 ////////////////////////////////////////////////////////////////////////////////
147
148 namespace SkTextureCompressor {
149
150 typedef SkData *(*CompressBitmapProc)(const SkBitmap &bitmap);
151
152 SkData *CompressBitmapToConfig(const SkBitmap &bitmap, Format config) {
153 CompressBitmapProc kProcMap[SkBitmap::kConfigCount][kFormatCnt];
154 memset(kProcMap, 0, sizeof(kProcMap));
155
156 // Map available bitmap configs to compression functions
157 kProcMap[SkBitmap::kA8_Config][kLATC_Format] = compress_a8_to_latc;
158
159 CompressBitmapProc proc = kProcMap[bitmap.config()][config];
160 if (NULL != proc) {
161 return proc(bitmap);
162 }
163
164 return NULL;
165 }
166
167 } // namespace SkTextureCompressor
OLDNEW
« src/utils/SkTextureCompressor.h ('K') | « src/utils/SkTextureCompressor.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698