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 "SkEndian.h"
9 #include "SkColorPriv.h"
10 #include "SkImageDecoder.h"
11 #include "SkScaledBitmapSampler.h"
12 #include "SkStream.h"
13 #include "SkStreamPriv.h"
14 #include "SkTypes.h"
15
16 #include "SkTextureCompressor.h"
17
18 class SkASTCImageDecoder : public SkImageDecoder {
19 public:
SkASTCImageDecoder()20 SkASTCImageDecoder() { }
21
getFormat() const22 Format getFormat() const override {
23 return kASTC_Format;
24 }
25
26 protected:
27 Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
28
29 private:
30 typedef SkImageDecoder INHERITED;
31 };
32
33 /////////////////////////////////////////////////////////////////////////////////////////
34
35 static const uint32_t kASTCMagicNumber = 0x5CA1AB13;
36
read_24bit(const uint8_t * buf)37 static inline int read_24bit(const uint8_t* buf) {
38 // Assume everything is little endian...
39 return
40 static_cast<int>(buf[0]) |
41 (static_cast<int>(buf[1]) << 8) |
42 (static_cast<int>(buf[2]) << 16);
43 }
44
onDecode(SkStream * stream,SkBitmap * bm,Mode mode)45 SkImageDecoder::Result SkASTCImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
46 SkAutoMalloc autoMal;
47 const size_t length = SkCopyStreamToStorage(&autoMal, stream);
48 if (0 == length) {
49 return kFailure;
50 }
51
52 unsigned char* buf = (unsigned char*)autoMal.get();
53
54 // Make sure that the magic header is there...
55 SkASSERT(SkEndian_SwapLE32(*(reinterpret_cast<uint32_t*>(buf))) == kASTCMagicNumber);
56
57 // Advance past the magic header
58 buf += 4;
59
60 const int blockDimX = buf[0];
61 const int blockDimY = buf[1];
62 const int blockDimZ = buf[2];
63
64 if (1 != blockDimZ) {
65 // We don't support decoding 3D
66 return kFailure;
67 }
68
69 // Choose the proper ASTC format
70 SkTextureCompressor::Format astcFormat;
71 if (4 == blockDimX && 4 == blockDimY) {
72 astcFormat = SkTextureCompressor::kASTC_4x4_Format;
73 } else if (5 == blockDimX && 4 == blockDimY) {
74 astcFormat = SkTextureCompressor::kASTC_5x4_Format;
75 } else if (5 == blockDimX && 5 == blockDimY) {
76 astcFormat = SkTextureCompressor::kASTC_5x5_Format;
77 } else if (6 == blockDimX && 5 == blockDimY) {
78 astcFormat = SkTextureCompressor::kASTC_6x5_Format;
79 } else if (6 == blockDimX && 6 == blockDimY) {
80 astcFormat = SkTextureCompressor::kASTC_6x6_Format;
81 } else if (8 == blockDimX && 5 == blockDimY) {
82 astcFormat = SkTextureCompressor::kASTC_8x5_Format;
83 } else if (8 == blockDimX && 6 == blockDimY) {
84 astcFormat = SkTextureCompressor::kASTC_8x6_Format;
85 } else if (8 == blockDimX && 8 == blockDimY) {
86 astcFormat = SkTextureCompressor::kASTC_8x8_Format;
87 } else if (10 == blockDimX && 5 == blockDimY) {
88 astcFormat = SkTextureCompressor::kASTC_10x5_Format;
89 } else if (10 == blockDimX && 6 == blockDimY) {
90 astcFormat = SkTextureCompressor::kASTC_10x6_Format;
91 } else if (10 == blockDimX && 8 == blockDimY) {
92 astcFormat = SkTextureCompressor::kASTC_10x8_Format;
93 } else if (10 == blockDimX && 10 == blockDimY) {
94 astcFormat = SkTextureCompressor::kASTC_10x10_Format;
95 } else if (12 == blockDimX && 10 == blockDimY) {
96 astcFormat = SkTextureCompressor::kASTC_12x10_Format;
97 } else if (12 == blockDimX && 12 == blockDimY) {
98 astcFormat = SkTextureCompressor::kASTC_12x12_Format;
99 } else {
100 // We don't support any other block dimensions..
101 return kFailure;
102 }
103
104 // Advance buf past the block dimensions
105 buf += 3;
106
107 // Read the width/height/depth from the buffer...
108 const int width = read_24bit(buf);
109 const int height = read_24bit(buf + 3);
110 const int depth = read_24bit(buf + 6);
111
112 if (1 != depth) {
113 // We don't support decoding 3D.
114 return kFailure;
115 }
116
117 // Advance the buffer past the image dimensions
118 buf += 9;
119
120 // Setup the sampler...
121 SkScaledBitmapSampler sampler(width, height, this->getSampleSize());
122
123 // Determine the alpha of the bitmap...
124 SkAlphaType alphaType = kOpaque_SkAlphaType;
125 if (this->getRequireUnpremultipliedColors()) {
126 alphaType = kUnpremul_SkAlphaType;
127 } else {
128 alphaType = kPremul_SkAlphaType;
129 }
130
131 // Set the config...
132 bm->setInfo(SkImageInfo::MakeN32(sampler.scaledWidth(), sampler.scaledHeight(), alphaType));
133
134 if (SkImageDecoder::kDecodeBounds_Mode == mode) {
135 return kSuccess;
136 }
137
138 if (!this->allocPixelRef(bm, NULL)) {
139 return kFailure;
140 }
141
142 // Lock the pixels, since we're about to write to them...
143 SkAutoLockPixels alp(*bm);
144
145 if (!sampler.begin(bm, SkScaledBitmapSampler::kRGBA, *this)) {
146 return kFailure;
147 }
148
149 // ASTC Data is encoded as RGBA pixels, so we should extract it as such
150 int nPixels = width * height;
151 SkAutoMalloc outRGBAData(nPixels * 4);
152 uint8_t *outRGBADataPtr = reinterpret_cast<uint8_t *>(outRGBAData.get());
153
154 // Decode ASTC
155 if (!SkTextureCompressor::DecompressBufferFromFormat(
156 outRGBADataPtr, width*4, buf, width, height, astcFormat)) {
157 return kFailure;
158 }
159
160 // Set each of the pixels...
161 const int srcRowBytes = width * 4;
162 const int dstHeight = sampler.scaledHeight();
163 const uint8_t *srcRow = reinterpret_cast<uint8_t *>(outRGBADataPtr);
164 srcRow += sampler.srcY0() * srcRowBytes;
165 for (int y = 0; y < dstHeight; ++y) {
166 sampler.next(srcRow);
167 srcRow += sampler.srcDY() * srcRowBytes;
168 }
169
170 return kSuccess;
171 }
172
173 /////////////////////////////////////////////////////////////////////////////////////////
174 DEFINE_DECODER_CREATOR(ASTCImageDecoder);
175 /////////////////////////////////////////////////////////////////////////////////////////
176
is_astc(SkStreamRewindable * stream)177 static bool is_astc(SkStreamRewindable* stream) {
178 // Read the ASTC header and make sure it's valid.
179 uint32_t magic;
180 if (stream->read((void*)&magic, 4) != 4) {
181 return false;
182 }
183
184 return kASTCMagicNumber == SkEndian_SwapLE32(magic);
185 }
186
sk_libastc_dfactory(SkStreamRewindable * stream)187 static SkImageDecoder* sk_libastc_dfactory(SkStreamRewindable* stream) {
188 if (is_astc(stream)) {
189 return SkNEW(SkASTCImageDecoder);
190 }
191 return NULL;
192 }
193
194 static SkImageDecoder_DecodeReg gReg(sk_libastc_dfactory);
195
get_format_astc(SkStreamRewindable * stream)196 static SkImageDecoder::Format get_format_astc(SkStreamRewindable* stream) {
197 if (is_astc(stream)) {
198 return SkImageDecoder::kASTC_Format;
199 }
200 return SkImageDecoder::kUnknown_Format;
201 }
202
203 static SkImageDecoder_FormatReg gFormatReg(get_format_astc);
204