1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkKTXFile_DEFINED
#define SkKTXFile_DEFINED
#include "SkData.h"
#include "SkTextureCompressor.h"
#include "SkTypes.h"
#include "SkTDArray.h"
#include "SkString.h"
#include "SkRefCnt.h"
class SkBitmap;
class SkStreamRewindable;
class SkWStream;
// KTX Image File
// ---
// KTX is a general texture data storage file format ratified by the Khronos Group. As an
// overview, a KTX file contains all of the appropriate values needed to fully specify a
// texture in an OpenGL application, including the use of compressed data.
//
// A full format specification can be found here:
// http://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
class SkKTXFile {
public:
// The ownership of the data remains with the caller. This class is intended
// to be used as a logical wrapper around the data in order to properly
// access the pixels.
SkKTXFile(SkData* data)
: fData(data), fSwapBytes(false)
{
data->ref();
fValid = this->readKTXFile(fData->bytes(), fData->size());
}
bool valid() const { return fValid; }
int width() const { return static_cast<int>(fHeader.fPixelWidth); }
int height() const { return static_cast<int>(fHeader.fPixelHeight); }
const uint8_t *pixelData(int mipmap = 0) const {
SkASSERT(!this->valid() || mipmap < fPixelData.count());
return this->valid() ? fPixelData[mipmap].data() : NULL;
}
// If the decoded KTX file has the following key, then it will
// return the associated value. If not found, the empty string
// is returned.
SkString getValueForKey(const SkString& key) const;
int numMipmaps() const { return static_cast<int>(fHeader.fNumberOfMipmapLevels); }
bool isCompressedFormat(SkTextureCompressor::Format fmt) const;
bool isRGBA8() const;
bool isRGB8() const;
static bool is_ktx(const uint8_t *data);
static bool is_ktx(SkStreamRewindable* stream);
static bool WriteETC1ToKTX(SkWStream* stream, const uint8_t *etc1Data,
uint32_t width, uint32_t height);
static bool WriteBitmapToKTX(SkWStream* stream, const SkBitmap& bitmap);
private:
// The blob holding the file data.
SkAutoTUnref<SkData> fData;
// This header captures all of the data that describes the format
// of the image data in a KTX file.
struct Header {
uint32_t fGLType;
uint32_t fGLTypeSize;
uint32_t fGLFormat;
uint32_t fGLInternalFormat;
uint32_t fGLBaseInternalFormat;
uint32_t fPixelWidth;
uint32_t fPixelHeight;
uint32_t fPixelDepth;
uint32_t fNumberOfArrayElements;
uint32_t fNumberOfFaces;
uint32_t fNumberOfMipmapLevels;
uint32_t fBytesOfKeyValueData;
Header() { memset(this, 0, sizeof(*this)); }
} fHeader;
// A Key Value pair stored in the KTX file. There may be
// arbitrarily many of these.
class KeyValue {
public:
KeyValue(size_t size) : fDataSz(size) { }
bool readKeyAndValue(const uint8_t *data);
size_t size() const { return fDataSz; }
const SkString& key() const { return fKey; }
const SkString& value() const { return fValue; }
bool writeKeyAndValueForKTX(SkWStream* strm);
private:
const size_t fDataSz;
SkString fKey;
SkString fValue;
};
static KeyValue CreateKeyValue(const char *key, const char *value);
// The pixel data for a single mipmap level in an image. Based on how
// the rest of the data is stored, this may be compressed, a cubemap, etc.
// The header will describe the format of this data.
class PixelData {
public:
PixelData(const uint8_t *ptr, size_t sz) : fDataSz(sz), fDataPtr(ptr) { }
const uint8_t *data() const { return fDataPtr; }
size_t dataSize() const { return fDataSz; }
private:
const size_t fDataSz;
const uint8_t *fDataPtr;
};
// This function is only called once from the constructor. It loads the data
// and populates the appropriate fields of this class
// (fKeyValuePairs, fPixelData, fSwapBytes)
bool readKTXFile(const uint8_t *data, size_t dataLen);
SkTArray<KeyValue> fKeyValuePairs;
SkTDArray<PixelData> fPixelData;
bool fValid;
// If the endianness of the platform is different than the file,
// then we need to do proper byte swapping.
bool fSwapBytes;
// Read an integer from a buffer, advance the buffer, and swap
// bytes if fSwapBytes is set
uint32_t readInt(const uint8_t** buf, size_t* bytesLeft) const;
};
#endif // SkKTXFile_DEFINED
|
