blob: 499db6ab484ecfa901941869895bbb6ff4e721d3 [file] [log] [blame]
krajcevskic250d2e2014-06-06 06:16:28 -07001/*
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
tfarinabcbc1782014-06-18 14:32:48 -07008#include "Resources.h"
krajcevskic250d2e2014-06-06 06:16:28 -07009#include "SkBitmap.h"
10#include "SkData.h"
11#include "SkDecodingImageGenerator.h"
12#include "SkForceLinking.h"
13#include "SkImageDecoder.h"
14#include "SkOSFile.h"
15#include "SkRandom.h"
16#include "SkStream.h"
17#include "Test.h"
18
19__SK_FORCE_IMAGE_DECODER_LINKING;
20
21/**
22 * First, make sure that writing an 8-bit RGBA KTX file and then
23 * reading it produces the same bitmap.
24 */
25DEF_TEST(KtxReadWrite, reporter) {
26
27 // Random number generator with explicit seed for reproducibility
28 SkRandom rand(0x1005cbad);
29
30 SkBitmap bm8888;
reed84825042014-09-02 12:50:45 -070031 bm8888.allocN32Pixels(128, 128);
krajcevskic250d2e2014-06-06 06:16:28 -070032
33 uint8_t *pixels = reinterpret_cast<uint8_t*>(bm8888.getPixels());
bsalomon49f085d2014-09-05 13:34:00 -070034 REPORTER_ASSERT(reporter, pixels);
krajcevskic250d2e2014-06-06 06:16:28 -070035
36 if (NULL == pixels) {
37 return;
38 }
39
40 uint8_t *row = pixels;
41 for (int y = 0; y < bm8888.height(); ++y) {
42 for (int x = 0; x < bm8888.width(); ++x) {
43 uint8_t a = rand.nextRangeU(0, 255);
44 uint8_t r = rand.nextRangeU(0, 255);
45 uint8_t g = rand.nextRangeU(0, 255);
46 uint8_t b = rand.nextRangeU(0, 255);
47
48 SkPMColor &pixel = *(reinterpret_cast<SkPMColor*>(row + x*sizeof(SkPMColor)));
49 pixel = SkPreMultiplyARGB(a, r, g, b);
50 }
51 row += bm8888.rowBytes();
52 }
53 REPORTER_ASSERT(reporter, !(bm8888.empty()));
54
55 SkAutoDataUnref encodedData(SkImageEncoder::EncodeData(bm8888, SkImageEncoder::kKTX_Type, 0));
bsalomon49f085d2014-09-05 13:34:00 -070056 REPORTER_ASSERT(reporter, encodedData);
krajcevskic250d2e2014-06-06 06:16:28 -070057
58 SkAutoTUnref<SkMemoryStream> stream(SkNEW_ARGS(SkMemoryStream, (encodedData)));
bsalomon49f085d2014-09-05 13:34:00 -070059 REPORTER_ASSERT(reporter, stream);
krajcevskic250d2e2014-06-06 06:16:28 -070060
61 SkBitmap decodedBitmap;
62 bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
63 REPORTER_ASSERT(reporter, imageDecodeSuccess);
64
reedc3b32662014-06-17 08:38:31 -070065 REPORTER_ASSERT(reporter, decodedBitmap.colorType() == bm8888.colorType());
krajcevskic250d2e2014-06-06 06:16:28 -070066 REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == bm8888.alphaType());
67 REPORTER_ASSERT(reporter, decodedBitmap.width() == bm8888.width());
68 REPORTER_ASSERT(reporter, decodedBitmap.height() == bm8888.height());
69 REPORTER_ASSERT(reporter, !(decodedBitmap.empty()));
70
71 uint8_t *decodedPixels = reinterpret_cast<uint8_t*>(decodedBitmap.getPixels());
bsalomon49f085d2014-09-05 13:34:00 -070072 REPORTER_ASSERT(reporter, decodedPixels);
krajcevskic250d2e2014-06-06 06:16:28 -070073 REPORTER_ASSERT(reporter, decodedBitmap.getSize() == bm8888.getSize());
74
75 if (NULL == decodedPixels) {
76 return;
77 }
78
79 REPORTER_ASSERT(reporter, memcmp(decodedPixels, pixels, decodedBitmap.getSize()) == 0);
80}
81
82/**
83 * Next test is to see whether or not reading an unpremultiplied KTX file accurately
84 * creates a premultiplied buffer...
85 */
86DEF_TEST(KtxReadUnpremul, reporter) {
87
88 static const uint8_t kHalfWhiteKTX[] = {
89 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, // First twelve bytes is magic
90 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A, // KTX identifier string
91 0x01, 0x02, 0x03, 0x04, // Then magic endian specifier
92 0x01, 0x14, 0x00, 0x00, // uint32_t fGLType;
93 0x01, 0x00, 0x00, 0x00, // uint32_t fGLTypeSize;
94 0x08, 0x19, 0x00, 0x00, // uint32_t fGLFormat;
95 0x58, 0x80, 0x00, 0x00, // uint32_t fGLInternalFormat;
96 0x08, 0x19, 0x00, 0x00, // uint32_t fGLBaseInternalFormat;
97 0x02, 0x00, 0x00, 0x00, // uint32_t fPixelWidth;
98 0x02, 0x00, 0x00, 0x00, // uint32_t fPixelHeight;
99 0x00, 0x00, 0x00, 0x00, // uint32_t fPixelDepth;
100 0x00, 0x00, 0x00, 0x00, // uint32_t fNumberOfArrayElements;
101 0x01, 0x00, 0x00, 0x00, // uint32_t fNumberOfFaces;
102 0x01, 0x00, 0x00, 0x00, // uint32_t fNumberOfMipmapLevels;
103 0x00, 0x00, 0x00, 0x00, // uint32_t fBytesOfKeyValueData;
104 0x10, 0x00, 0x00, 0x00, // image size: 2x2 image of RGBA = 4 * 4 = 16 bytes
105 0xFF, 0xFF, 0xFF, 0x80, // Pixel 1
106 0xFF, 0xFF, 0xFF, 0x80, // Pixel 2
107 0xFF, 0xFF, 0xFF, 0x80, // Pixel 3
108 0xFF, 0xFF, 0xFF, 0x80};// Pixel 4
109
110 SkAutoTUnref<SkMemoryStream> stream(
111 SkNEW_ARGS(SkMemoryStream, (kHalfWhiteKTX, sizeof(kHalfWhiteKTX))));
bsalomon49f085d2014-09-05 13:34:00 -0700112 REPORTER_ASSERT(reporter, stream);
krajcevskic250d2e2014-06-06 06:16:28 -0700113
114 SkBitmap decodedBitmap;
115 bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
116 REPORTER_ASSERT(reporter, imageDecodeSuccess);
117
reed0689d7b2014-06-14 05:30:20 -0700118 REPORTER_ASSERT(reporter, decodedBitmap.colorType() == kN32_SkColorType);
krajcevskic250d2e2014-06-06 06:16:28 -0700119 REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == kPremul_SkAlphaType);
120 REPORTER_ASSERT(reporter, decodedBitmap.width() == 2);
121 REPORTER_ASSERT(reporter, decodedBitmap.height() == 2);
122 REPORTER_ASSERT(reporter, !(decodedBitmap.empty()));
123
124 uint8_t *decodedPixels = reinterpret_cast<uint8_t*>(decodedBitmap.getPixels());
bsalomon49f085d2014-09-05 13:34:00 -0700125 REPORTER_ASSERT(reporter, decodedPixels);
krajcevskic250d2e2014-06-06 06:16:28 -0700126
127 uint8_t *row = decodedPixels;
128 for (int j = 0; j < decodedBitmap.height(); ++j) {
129 for (int i = 0; i < decodedBitmap.width(); ++i) {
130 SkPMColor pixel = *(reinterpret_cast<SkPMColor*>(row + i*sizeof(SkPMColor)));
131 REPORTER_ASSERT(reporter, SkPreMultiplyARGB(0x80, 0xFF, 0xFF, 0xFF) == pixel);
132 }
133 row += decodedBitmap.rowBytes();
134 }
135}
136
137/**
138 * Finally, make sure that if we get ETC1 data from a PKM file that we can then
139 * accurately write it out into a KTX file (i.e. transferring the ETC1 data from
140 * the PKM to the KTX should produce an identical KTX to the one we have on file)
141 */
142DEF_TEST(KtxReexportPKM, reporter) {
tfarinac846f4a2014-07-01 12:35:49 -0700143 SkString pkmFilename = GetResourcePath("mandrill_128.pkm");
krajcevskic250d2e2014-06-06 06:16:28 -0700144
145 // Load PKM file into a bitmap
146 SkBitmap etcBitmap;
tfarinac846f4a2014-07-01 12:35:49 -0700147 SkAutoTUnref<SkData> fileData(SkData::NewFromFileName(pkmFilename.c_str()));
reed7a7c3162014-07-02 05:57:50 -0700148 if (NULL == fileData) {
reed15c74602014-10-28 07:12:37 -0700149 SkDebugf("KtxReexportPKM: can't load test file %s\n", pkmFilename.c_str());
reed7a7c3162014-07-02 05:57:50 -0700150 return;
151 }
krajcevskic250d2e2014-06-06 06:16:28 -0700152
153 bool installDiscardablePixelRefSuccess =
154 SkInstallDiscardablePixelRef(
155 SkDecodingImageGenerator::Create(
156 fileData, SkDecodingImageGenerator::Options()), &etcBitmap);
157 REPORTER_ASSERT(reporter, installDiscardablePixelRefSuccess);
158
159 // Write the bitmap out to a KTX file.
160 SkData *ktxDataPtr = SkImageEncoder::EncodeData(etcBitmap, SkImageEncoder::kKTX_Type, 0);
161 SkAutoDataUnref newKtxData(ktxDataPtr);
bsalomon49f085d2014-09-05 13:34:00 -0700162 REPORTER_ASSERT(reporter, ktxDataPtr);
krajcevskic250d2e2014-06-06 06:16:28 -0700163
164 // See is this data is identical to data in existing ktx file.
tfarinac846f4a2014-07-01 12:35:49 -0700165 SkString ktxFilename = GetResourcePath("mandrill_128.ktx");
krajcevskic250d2e2014-06-06 06:16:28 -0700166 SkAutoDataUnref oldKtxData(SkData::NewFromFileName(ktxFilename.c_str()));
167 REPORTER_ASSERT(reporter, oldKtxData->equals(newKtxData));
168}