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

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: Compute palette indices with palette 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
« include/core/SkTypes.h ('K') | « src/utils/SkTextureCompressor.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 // LATC compressor
17 //
18 ////////////////////////////////////////////////////////////////////////////////
19
20 // Return the squared minimum error cost of approximating 'pixel' using the
21 // provided palette. Return this in the middle 16 bits of the integer. Return
22 // the best index in the palette for this pixel in the bottom 8 bits.
23 static uint32_t compute_error(uint8_t pixel, uint8_t palette[8]) {
24 int minIndex = 0;
25 uint8_t error = SkTAbsDiff(palette[0], pixel);
26 for (int i = 1; i < 8; ++i) {
27 uint8_t diff = SkTAbsDiff(palette[i], pixel);
28 if (diff < error) {
29 minIndex = i;
30 error = diff;
31 }
32 }
33 uint16_t errSq = static_cast<uint16_t>(error) * static_cast<uint16_t>(error) ;
34 SkASSERT(minIndex >= 0 && minIndex < 8);
35 return (static_cast<uint32_t>(errSq) << 8) | static_cast<uint32_t>(minIndex) ;
36 }
37
38 // Compress LATC block. Each 4x4 block of pixels is decompressed by LATC from tw o
39 // values LUM0 and LUM1, and an index into the generated palette. LATC construct s
40 // a palette of eight colors from LUM0 and LUM1 using the algorithm:
41 //
42 // LUM0, if lum0 > lum1 and code(x,y) == 0
43 // LUM1, if lum0 > lum1 and code(x,y) == 1
44 // (6*LUM0+ LUM1)/7, if lum0 > lum1 and code(x,y) == 2
45 // (5*LUM0+2*LUM1)/7, if lum0 > lum1 and code(x,y) == 3
46 // (4*LUM0+3*LUM1)/7, if lum0 > lum1 and code(x,y) == 4
47 // (3*LUM0+4*LUM1)/7, if lum0 > lum1 and code(x,y) == 5
48 // (2*LUM0+5*LUM1)/7, if lum0 > lum1 and code(x,y) == 6
49 // ( LUM0+6*LUM1)/7, if lum0 > lum1 and code(x,y) == 7
50 //
51 // LUM0, if lum0 <= lum1 and code(x,y) == 0
52 // LUM1, if lum0 <= lum1 and code(x,y) == 1
53 // (4*LUM0+ LUM1)/5, if lum0 <= lum1 and code(x,y) == 2
54 // (3*LUM0+2*LUM1)/5, if lum0 <= lum1 and code(x,y) == 3
55 // (2*LUM0+3*LUM1)/5, if lum0 <= lum1 and code(x,y) == 4
56 // ( LUM0+4*LUM1)/5, if lum0 <= lum1 and code(x,y) == 5
57 // 0, if lum0 <= lum1 and code(x,y) == 6
58 // 255, if lum0 <= lum1 and code(x,y) == 7
59 //
60 // We compute the LATC palette using the following simple algorithm:
61 // 1. Choose the minimum and maximum values in the block as LUM0 and LUM1
62 // 2. Figure out which of the two possible palettes is better.
63
64 static uint64_t compress_latc_block(uint8_t block[16]) {
robertphillips 2014/06/09 22:12:40 from which -> which ?
krajcevski 2014/06/10 14:38:09 Done.
65 // Just do a simple min/max but choose from which of the
66 // two palettes is better
67 uint8_t maxVal = 0;
68 uint8_t minVal = 255;
69 for (int i = 0; i < 16; ++i) {
70 maxVal = SkMax32(maxVal, block[i]);
71 minVal = SkMin32(minVal, block[i]);
72 }
73
74 // Generate palettes
75 uint8_t palettes[2][8];
76
77 // Straight linear ramp
78 palettes[0][0] = maxVal;
79 palettes[0][1] = minVal;
80 for (int i = 1; i < 7; ++i) {
81 palettes[0][i+1] = ((7-i)*maxVal + i*minVal) / 7;
82 }
83
84 // Smaller linear ramp with min and max byte values at the end.
85 palettes[1][0] = minVal;
86 palettes[1][1] = maxVal;
87 for (int i = 1; i < 5; ++i) {
88 palettes[1][i+1] = ((5-i)*maxVal + i*minVal) / 5;
89 }
90 palettes[1][6] = 0;
91 palettes[1][7] = 255;
92
93 // Figure out which of the two is better:
94 // - accumError holds the accumulated error for each pixel from
95 // the associated palette
96 // - indices holds the best indices for each palette in the
97 // bottom 48 (16*3) bits.
98 uint32_t accumError[2] = { 0, 0 };
99 uint64_t indices[2] = { 0, 0 };
100 for (int i = 15; i >= 0; ++i) {
101 uint16_t pixel = static_cast<uint16_t>(block[i]);
102
103 // For each palette:
104 // 1. Retreive the result of this pixel
105 // 2. Store the error in accumError
106 // 3. Store the minimum palette index in indices.
107 for (int p = 0; p < 2; ++p) {
108 uint32_t result = compute_error(pixel, palettes[p]);
109 accumError[p] += (result >> 8);
110 indices[p] <<= 3;
111 indices[p] |= result & ~7;
112 }
113 }
114
115 SkASSERT(indices[0] < (1 << 48));
116 SkASSERT(indices[1] < (1 << 48));
117
118 uint8_t paletteIdx = (accumError[0] > accumError[1]) ? 0 : 1;
119
robertphillips 2014/06/09 22:12:40 // Assemble the compressed block ?
krajcevski 2014/06/10 14:38:09 Done.
120 // Compress the chosen palette
121 uint64_t result = 0;
122
123 // Jam the first two palette entries into the bottom 16 bits of
124 // a 64 bit integer. Based on the palette that we chose, one will
125 // be larger than the other and it will select the proper palette.
126 result |= static_cast<uint64_t>(palettes[paletteIdx][0]);
127 result |= static_cast<uint64_t>(palettes[paletteIdx][1]) << 8;
128
129 // Jam the indices into the top 48 bits.
130 result |= indices[paletteIdx] << 16;
131
132 // We assume everything is little endian, if it's not then make it so.
133 return SkEndian_SwapLE64(result);
134 }
135
136 static SkData *compress_a8_to_latc(const SkBitmap &bm) {
137 // LATC compressed texels down into square 4x4 blocks
138 static const int kLATCBlockSize = 4;
139
140 // Make sure that our data is well-formed enough to be
141 // considered for LATC compression
142 if (bm.width() == 0 || bm.height() == 0 ||
143 (bm.width() % kLATCBlockSize) != 0 ||
144 (bm.height() % kLATCBlockSize) != 0 ||
145 (bm.colorType() != kAlpha_8_SkColorType)) {
146 return NULL;
147 }
148
149 // The LATC format is 64 bits per 4x4 block.
150 static const int kLATCEncodedBlockSize = 8;
151
152 int blocksX = bm.width() / kLATCBlockSize;
153 int blocksY = bm.height() / kLATCBlockSize;
154
155 int compressedDataSize = blocksX * blocksY * kLATCEncodedBlockSize;
156 uint64_t* dst = reinterpret_cast<uint64_t*>(sk_malloc_throw(compressedDataSi ze));
157
158 uint8_t block[16];
159 const uint8_t* row = reinterpret_cast<const uint8_t*>(bm.getPixels());
160 uint64_t* encPtr = dst;
161 for (int y = 0; y < blocksY; ++y) {
162 for (int x = 0; x < blocksX; ++x) {
163 memcpy(block, row + (kLATCBlockSize * x), 4);
164 memcpy(block + 4, row + bm.rowBytes() + (kLATCBlockSize * x), 4);
165 memcpy(block + 8, row + 2*bm.rowBytes() + (kLATCBlockSize * x), 4);
166 memcpy(block + 12, row + 3*bm.rowBytes() + (kLATCBlockSize * x), 4);
167
168 *encPtr = compress_latc_block(block);
169 ++encPtr;
170 }
171 row += kLATCBlockSize * bm.rowBytes();
172 }
173
174 return SkData::NewFromMalloc(dst, compressedDataSize);
175 }
176
177 ////////////////////////////////////////////////////////////////////////////////
178
179 namespace SkTextureCompressor {
180
181 typedef SkData *(*CompressBitmapProc)(const SkBitmap &bitmap);
182
183 SkData *CompressBitmapToFormat(const SkBitmap &bitmap, Format format) {
184 CompressBitmapProc kProcMap[kLastEnum_SkColorType + 1][kFormatCnt];
185 memset(kProcMap, 0, sizeof(kProcMap));
186
187 // Map available bitmap configs to compression functions
188 kProcMap[SkBitmap::kA8_Config][kLATC_Format] = compress_a8_to_latc;
189
190 CompressBitmapProc proc = kProcMap[bitmap.colorType()][format];
191 if (NULL != proc) {
192 return proc(bitmap);
193 }
194
195 return NULL;
196 }
197
198 } // namespace SkTextureCompressor
OLDNEW
« include/core/SkTypes.h ('K') | « src/utils/SkTextureCompressor.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698