summaryrefslogtreecommitdiffstats
path: root/dom/canvas/WebGLFormats.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/canvas/WebGLFormats.cpp')
-rw-r--r--dom/canvas/WebGLFormats.cpp1126
1 files changed, 1126 insertions, 0 deletions
diff --git a/dom/canvas/WebGLFormats.cpp b/dom/canvas/WebGLFormats.cpp
new file mode 100644
index 000000000..d2fc38548
--- /dev/null
+++ b/dom/canvas/WebGLFormats.cpp
@@ -0,0 +1,1126 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGLFormats.h"
+
+#include "gfxPrefs.h"
+#include "GLContext.h"
+#include "GLDefs.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/StaticMutex.h"
+
+#ifdef FOO
+#error FOO is already defined! We use FOO() macros to keep things succinct in this file.
+#endif
+
+namespace mozilla {
+namespace webgl {
+
+template<typename K, typename V, typename K2, typename V2>
+static inline void
+AlwaysInsert(std::map<K,V>& dest, const K2& key, const V2& val)
+{
+ auto res = dest.insert({ key, val });
+ bool didInsert = res.second;
+ MOZ_ALWAYS_TRUE(didInsert);
+}
+
+template<typename K, typename V, typename K2>
+static inline V*
+FindOrNull(const std::map<K,V*>& dest, const K2& key)
+{
+ auto itr = dest.find(key);
+ if (itr == dest.end())
+ return nullptr;
+
+ return itr->second;
+}
+
+// Returns a pointer to the in-place value for `key`.
+template<typename K, typename V, typename K2>
+static inline V*
+FindPtrOrNull(std::map<K,V>& dest, const K2& key)
+{
+ auto itr = dest.find(key);
+ if (itr == dest.end())
+ return nullptr;
+
+ return &(itr->second);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+std::map<EffectiveFormat, const CompressedFormatInfo> gCompressedFormatInfoMap;
+std::map<EffectiveFormat, FormatInfo> gFormatInfoMap;
+
+static inline const CompressedFormatInfo*
+GetCompressedFormatInfo(EffectiveFormat format)
+{
+ MOZ_ASSERT(!gCompressedFormatInfoMap.empty());
+ return FindPtrOrNull(gCompressedFormatInfoMap, format);
+}
+
+static inline FormatInfo*
+GetFormatInfo_NoLock(EffectiveFormat format)
+{
+ MOZ_ASSERT(!gFormatInfoMap.empty());
+ return FindPtrOrNull(gFormatInfoMap, format);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+static void
+AddCompressedFormatInfo(EffectiveFormat format, uint16_t bitsPerBlock, uint8_t blockWidth,
+ uint8_t blockHeight, CompressionFamily family)
+{
+ MOZ_ASSERT(bitsPerBlock % 8 == 0);
+ uint16_t bytesPerBlock = bitsPerBlock / 8; // The specs always state these in bits,
+ // but it's only ever useful to us as
+ // bytes.
+ MOZ_ASSERT(bytesPerBlock <= 255);
+
+ const CompressedFormatInfo info = { format, uint8_t(bytesPerBlock), blockWidth,
+ blockHeight, family };
+ AlwaysInsert(gCompressedFormatInfoMap, format, info);
+}
+
+static void
+InitCompressedFormatInfo()
+{
+ // GLES 3.0.4, p147, table 3.19
+ // GLES 3.0.4, p286+, $C.1 "ETC Compressed Texture Image Formats"
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGB8_ETC2 , 64, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_SRGB8_ETC2 , 64, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA8_ETC2_EAC , 128, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC , 128, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_R11_EAC , 64, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RG11_EAC , 128, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_SIGNED_R11_EAC , 64, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_SIGNED_RG11_EAC , 128, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 , 64, 4, 4, CompressionFamily::ES3);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 64, 4, 4, CompressionFamily::ES3);
+
+ // AMD_compressed_ATC_texture
+ AddCompressedFormatInfo(EffectiveFormat::ATC_RGB_AMD , 64, 4, 4, CompressionFamily::ATC);
+ AddCompressedFormatInfo(EffectiveFormat::ATC_RGBA_EXPLICIT_ALPHA_AMD , 128, 4, 4, CompressionFamily::ATC);
+ AddCompressedFormatInfo(EffectiveFormat::ATC_RGBA_INTERPOLATED_ALPHA_AMD, 128, 4, 4, CompressionFamily::ATC);
+
+ // EXT_texture_compression_s3tc
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGB_S3TC_DXT1_EXT , 64, 4, 4, CompressionFamily::S3TC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA_S3TC_DXT1_EXT, 64, 4, 4, CompressionFamily::S3TC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA_S3TC_DXT3_EXT, 128, 4, 4, CompressionFamily::S3TC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA_S3TC_DXT5_EXT, 128, 4, 4, CompressionFamily::S3TC);
+
+ // IMG_texture_compression_pvrtc
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGB_PVRTC_4BPPV1 , 256, 8, 8, CompressionFamily::PVRTC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA_PVRTC_4BPPV1, 256, 8, 8, CompressionFamily::PVRTC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGB_PVRTC_2BPPV1 , 256, 16, 8, CompressionFamily::PVRTC);
+ AddCompressedFormatInfo(EffectiveFormat::COMPRESSED_RGBA_PVRTC_2BPPV1, 256, 16, 8, CompressionFamily::PVRTC);
+
+ // OES_compressed_ETC1_RGB8_texture
+ AddCompressedFormatInfo(EffectiveFormat::ETC1_RGB8_OES, 64, 4, 4, CompressionFamily::ETC1);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+static void
+AddFormatInfo(EffectiveFormat format, const char* name, GLenum sizedFormat,
+ uint8_t bytesPerPixel, uint8_t r, uint8_t g, uint8_t b, uint8_t a,
+ uint8_t d, uint8_t s, UnsizedFormat unsizedFormat, bool isSRGB,
+ ComponentType componentType)
+{
+ switch (unsizedFormat) {
+ case UnsizedFormat::R:
+ MOZ_ASSERT(r && !g && !b && !a && !d && !s);
+ break;
+
+ case UnsizedFormat::RG:
+ MOZ_ASSERT(r && g && !b && !a && !d && !s);
+ break;
+
+ case UnsizedFormat::RGB:
+ MOZ_ASSERT(r && g && b && !a && !d && !s);
+ break;
+
+ case UnsizedFormat::RGBA:
+ MOZ_ASSERT(r && g && b && a && !d && !s);
+ break;
+
+ case UnsizedFormat::L:
+ MOZ_ASSERT(r && !g && !b && !a && !d && !s);
+ break;
+
+ case UnsizedFormat::A:
+ MOZ_ASSERT(!r && !g && !b && a && !d && !s);
+ break;
+
+ case UnsizedFormat::LA:
+ MOZ_ASSERT(r && !g && !b && a && !d && !s);
+ break;
+
+ case UnsizedFormat::D:
+ MOZ_ASSERT(!r && !g && !b && !a && d && !s);
+ break;
+
+ case UnsizedFormat::S:
+ MOZ_ASSERT(!r && !g && !b && !a && !d && s);
+ break;
+
+ case UnsizedFormat::DEPTH_STENCIL:
+ MOZ_ASSERT(!r && !g && !b && !a && d && s);
+ break;
+ }
+
+ const CompressedFormatInfo* compressedFormatInfo = GetCompressedFormatInfo(format);
+ MOZ_ASSERT(!bytesPerPixel == bool(compressedFormatInfo));
+
+#ifdef DEBUG
+ uint8_t totalBits = r + g + b + a + d + s;
+ if (format == EffectiveFormat::RGB9_E5) {
+ totalBits = 9 + 9 + 9 + 5;
+ }
+
+ if (compressedFormatInfo) {
+ MOZ_ASSERT(totalBits);
+ MOZ_ASSERT(!bytesPerPixel);
+ } else {
+ MOZ_ASSERT(totalBits == bytesPerPixel*8);
+ }
+#endif
+
+ const FormatInfo info = { format, name, sizedFormat, unsizedFormat, componentType,
+ isSRGB, compressedFormatInfo, bytesPerPixel, r,g,b,a,d,s };
+ AlwaysInsert(gFormatInfoMap, format, info);
+}
+
+static void
+InitFormatInfo()
+{
+#define FOO(x) EffectiveFormat::x, #x, LOCAL_GL_ ## x
+
+ // GLES 3.0.4, p130-132, table 3.13
+ AddFormatInfo(FOO(R8 ), 1, 8, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(R8_SNORM ), 1, 8, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::NormInt );
+ AddFormatInfo(FOO(RG8 ), 2, 8, 8, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RG8_SNORM ), 2, 8, 8, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::NormInt );
+ AddFormatInfo(FOO(RGB8 ), 3, 8, 8, 8, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGB8_SNORM ), 3, 8, 8, 8, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormInt );
+ AddFormatInfo(FOO(RGB565 ), 2, 5, 6, 5, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGBA4 ), 2, 4, 4, 4, 4, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGB5_A1 ), 2, 5, 5, 5, 1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGBA8 ), 4, 8, 8, 8, 8, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGBA8_SNORM ), 4, 8, 8, 8, 8, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormInt );
+ AddFormatInfo(FOO(RGB10_A2 ), 4, 10,10,10, 2, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(RGB10_A2UI ), 4, 10,10,10, 2, 0,0, UnsizedFormat::RGBA, false, ComponentType::UInt );
+
+ AddFormatInfo(FOO(SRGB8 ), 3, 8, 8, 8, 0, 0,0, UnsizedFormat::RGB , true , ComponentType::NormUInt);
+ AddFormatInfo(FOO(SRGB8_ALPHA8 ), 4, 8, 8, 8, 8, 0,0, UnsizedFormat::RGBA, true , ComponentType::NormUInt);
+
+ AddFormatInfo(FOO(R16F ), 2, 16, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::Float );
+ AddFormatInfo(FOO(RG16F ), 4, 16,16, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::Float );
+ AddFormatInfo(FOO(RGB16F ), 6, 16,16,16, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Float );
+ AddFormatInfo(FOO(RGBA16F ), 8, 16,16,16,16, 0,0, UnsizedFormat::RGBA, false, ComponentType::Float );
+ AddFormatInfo(FOO(R32F ), 4, 32, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::Float );
+ AddFormatInfo(FOO(RG32F ), 8, 32,32, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::Float );
+ AddFormatInfo(FOO(RGB32F ), 12, 32,32,32, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Float );
+ AddFormatInfo(FOO(RGBA32F ), 16, 32,32,32,32, 0,0, UnsizedFormat::RGBA, false, ComponentType::Float );
+
+ AddFormatInfo(FOO(R11F_G11F_B10F), 4, 11,11,10, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Float );
+ AddFormatInfo(FOO(RGB9_E5 ), 4, 14,14,14, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Float );
+
+ AddFormatInfo(FOO(R8I ), 1, 8, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::Int );
+ AddFormatInfo(FOO(R8UI ), 1, 8, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::UInt );
+ AddFormatInfo(FOO(R16I ), 2, 16, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::Int );
+ AddFormatInfo(FOO(R16UI ), 2, 16, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::UInt );
+ AddFormatInfo(FOO(R32I ), 4, 32, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::Int );
+ AddFormatInfo(FOO(R32UI ), 4, 32, 0, 0, 0, 0,0, UnsizedFormat::R , false, ComponentType::UInt );
+
+ AddFormatInfo(FOO(RG8I ), 2, 8, 8, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::Int );
+ AddFormatInfo(FOO(RG8UI ), 2, 8, 8, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::UInt );
+ AddFormatInfo(FOO(RG16I ), 4, 16,16, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::Int );
+ AddFormatInfo(FOO(RG16UI ), 4, 16,16, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::UInt );
+ AddFormatInfo(FOO(RG32I ), 8, 32,32, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::Int );
+ AddFormatInfo(FOO(RG32UI ), 8, 32,32, 0, 0, 0,0, UnsizedFormat::RG , false, ComponentType::UInt );
+
+ AddFormatInfo(FOO(RGB8I ), 3, 8, 8, 8, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Int );
+ AddFormatInfo(FOO(RGB8UI ), 3, 8, 8, 8, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::UInt );
+ AddFormatInfo(FOO(RGB16I ), 6, 16,16,16, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Int );
+ AddFormatInfo(FOO(RGB16UI ), 6, 16,16,16, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::UInt );
+ AddFormatInfo(FOO(RGB32I ), 12, 32,32,32, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::Int );
+ AddFormatInfo(FOO(RGB32UI ), 12, 32,32,32, 0, 0,0, UnsizedFormat::RGB , false, ComponentType::UInt );
+
+ AddFormatInfo(FOO(RGBA8I ), 4, 8, 8, 8, 8, 0,0, UnsizedFormat::RGBA, false, ComponentType::Int );
+ AddFormatInfo(FOO(RGBA8UI ), 4, 8, 8, 8, 8, 0,0, UnsizedFormat::RGBA, false, ComponentType::UInt );
+ AddFormatInfo(FOO(RGBA16I ), 8, 16,16,16,16, 0,0, UnsizedFormat::RGBA, false, ComponentType::Int );
+ AddFormatInfo(FOO(RGBA16UI ), 8, 16,16,16,16, 0,0, UnsizedFormat::RGBA, false, ComponentType::UInt );
+ AddFormatInfo(FOO(RGBA32I ), 16, 32,32,32,32, 0,0, UnsizedFormat::RGBA, false, ComponentType::Int );
+ AddFormatInfo(FOO(RGBA32UI ), 16, 32,32,32,32, 0,0, UnsizedFormat::RGBA, false, ComponentType::UInt );
+
+ // GLES 3.0.4, p133, table 3.14
+ AddFormatInfo(FOO(DEPTH_COMPONENT16 ), 2, 0,0,0,0, 16,0, UnsizedFormat::D , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(DEPTH_COMPONENT24 ), 3, 0,0,0,0, 24,0, UnsizedFormat::D , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(DEPTH_COMPONENT32F), 4, 0,0,0,0, 32,0, UnsizedFormat::D , false, ComponentType::Float);
+ AddFormatInfo(FOO(DEPTH24_STENCIL8 ), 4, 0,0,0,0, 24,8, UnsizedFormat::DEPTH_STENCIL, false, ComponentType::Special);
+ AddFormatInfo(FOO(DEPTH32F_STENCIL8 ), 5, 0,0,0,0, 32,8, UnsizedFormat::DEPTH_STENCIL, false, ComponentType::Special);
+
+ // GLES 3.0.4, p205-206, "Required Renderbuffer Formats"
+ AddFormatInfo(FOO(STENCIL_INDEX8), 1, 0,0,0,0, 0,8, UnsizedFormat::S, false, ComponentType::UInt);
+
+ // GLES 3.0.4, p147, table 3.19
+ // GLES 3.0.4 p286+ $C.1 "ETC Compressed Texture Image Formats"
+ AddFormatInfo(FOO(COMPRESSED_RGB8_ETC2 ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_SRGB8_ETC2 ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , true , ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA8_ETC2_EAC ), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_SRGB8_ALPHA8_ETC2_EAC ), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, true , ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_R11_EAC ), 0, 1,0,0,0, 0,0, UnsizedFormat::R , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RG11_EAC ), 0, 1,1,0,0, 0,0, UnsizedFormat::RG , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_SIGNED_R11_EAC ), 0, 1,0,0,0, 0,0, UnsizedFormat::R , false, ComponentType::NormInt );
+ AddFormatInfo(FOO(COMPRESSED_SIGNED_RG11_EAC ), 0, 1,1,0,0, 0,0, UnsizedFormat::RG , false, ComponentType::NormInt );
+ AddFormatInfo(FOO(COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 ), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, true , ComponentType::NormUInt);
+
+ // AMD_compressed_ATC_texture
+ AddFormatInfo(FOO(ATC_RGB_AMD ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(ATC_RGBA_EXPLICIT_ALPHA_AMD ), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(ATC_RGBA_INTERPOLATED_ALPHA_AMD), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+
+ // EXT_texture_compression_s3tc
+ AddFormatInfo(FOO(COMPRESSED_RGB_S3TC_DXT1_EXT ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA_S3TC_DXT1_EXT), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA_S3TC_DXT3_EXT), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA_S3TC_DXT5_EXT), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+
+ // IMG_texture_compression_pvrtc
+ AddFormatInfo(FOO(COMPRESSED_RGB_PVRTC_4BPPV1 ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA_PVRTC_4BPPV1), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGB_PVRTC_2BPPV1 ), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(COMPRESSED_RGBA_PVRTC_2BPPV1), 0, 1,1,1,1, 0,0, UnsizedFormat::RGBA, false, ComponentType::NormUInt);
+
+ // OES_compressed_ETC1_RGB8_texture
+ AddFormatInfo(FOO(ETC1_RGB8_OES), 0, 1,1,1,0, 0,0, UnsizedFormat::RGB, false, ComponentType::NormUInt);
+
+#undef FOO
+
+ // 'Virtual' effective formats have no sizedFormat.
+#define FOO(x) EffectiveFormat::x, #x, 0
+
+ // GLES 3.0.4, p128, table 3.12.
+ AddFormatInfo(FOO(Luminance8Alpha8), 2, 8,0,0,8, 0,0, UnsizedFormat::LA, false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(Luminance8 ), 1, 8,0,0,0, 0,0, UnsizedFormat::L , false, ComponentType::NormUInt);
+ AddFormatInfo(FOO(Alpha8 ), 1, 0,0,0,8, 0,0, UnsizedFormat::A , false, ComponentType::NormUInt);
+
+ // OES_texture_float
+ AddFormatInfo(FOO(Luminance32FAlpha32F), 8, 32,0,0,32, 0,0, UnsizedFormat::LA, false, ComponentType::Float);
+ AddFormatInfo(FOO(Luminance32F ), 4, 32,0,0, 0, 0,0, UnsizedFormat::L , false, ComponentType::Float);
+ AddFormatInfo(FOO(Alpha32F ), 4, 0,0,0,32, 0,0, UnsizedFormat::A , false, ComponentType::Float);
+
+ // OES_texture_half_float
+ AddFormatInfo(FOO(Luminance16FAlpha16F), 4, 16,0,0,16, 0,0, UnsizedFormat::LA, false, ComponentType::Float);
+ AddFormatInfo(FOO(Luminance16F ), 2, 16,0,0, 0, 0,0, UnsizedFormat::L , false, ComponentType::Float);
+ AddFormatInfo(FOO(Alpha16F ), 2, 0,0,0,16, 0,0, UnsizedFormat::A , false, ComponentType::Float);
+
+#undef FOO
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ const auto fnSetCopyDecay = [](EffectiveFormat src, EffectiveFormat asR,
+ EffectiveFormat asRG, EffectiveFormat asRGB,
+ EffectiveFormat asRGBA, EffectiveFormat asL,
+ EffectiveFormat asA, EffectiveFormat asLA)
+ {
+ auto& map = GetFormatInfo_NoLock(src)->copyDecayFormats;
+
+ const auto fnSet = [&map](UnsizedFormat uf, EffectiveFormat ef) {
+ if (ef == EffectiveFormat::MAX)
+ return;
+
+ const auto* format = GetFormatInfo_NoLock(ef);
+ MOZ_ASSERT(format->unsizedFormat == uf);
+ AlwaysInsert(map, uf, format);
+ };
+
+ fnSet(UnsizedFormat::R , asR);
+ fnSet(UnsizedFormat::RG , asRG);
+ fnSet(UnsizedFormat::RGB , asRGB);
+ fnSet(UnsizedFormat::RGBA, asRGBA);
+ fnSet(UnsizedFormat::L , asL);
+ fnSet(UnsizedFormat::A , asA);
+ fnSet(UnsizedFormat::LA , asLA);
+ };
+
+#define SET_COPY_DECAY(src,asR,asRG,asRGB,asRGBA,asL,asA,asLA) \
+ fnSetCopyDecay(EffectiveFormat::src, EffectiveFormat::asR, EffectiveFormat::asRG, \
+ EffectiveFormat::asRGB, EffectiveFormat::asRGBA, EffectiveFormat::asL, \
+ EffectiveFormat::asA, EffectiveFormat::asLA);
+
+ //////
+
+#define SET_BY_SUFFIX(X) \
+ SET_COPY_DECAY( R##X, R##X, MAX, MAX, MAX, Luminance##X, MAX, MAX) \
+ SET_COPY_DECAY( RG##X, R##X, RG##X, MAX, MAX, Luminance##X, MAX, MAX) \
+ SET_COPY_DECAY( RGB##X, R##X, RG##X, RGB##X, MAX, Luminance##X, MAX, MAX) \
+ SET_COPY_DECAY(RGBA##X, R##X, RG##X, RGB##X, RGBA##X, Luminance##X, Alpha##X, Luminance##X##Alpha##X)
+
+ SET_BY_SUFFIX(8) // WebGL decided that RGB8 should be guaranteed renderable.
+ SET_BY_SUFFIX(16F) // RGB16F is renderable in EXT_color_buffer_half_float, though not
+ // EXT_color_buffer_float.
+ SET_BY_SUFFIX(32F) // Technically RGB32F is never renderable, but no harm here.
+
+#undef SET_BY_SUFFIX
+
+ //////
+
+#define SET_BY_SUFFIX(X) \
+ SET_COPY_DECAY( R##X, R##X, MAX, MAX, MAX, MAX, MAX, MAX) \
+ SET_COPY_DECAY( RG##X, R##X, RG##X, MAX, MAX, MAX, MAX, MAX) \
+ SET_COPY_DECAY(RGBA##X, R##X, RG##X, RGB##X, RGBA##X, MAX, MAX, MAX)
+
+ SET_BY_SUFFIX(8I)
+ SET_BY_SUFFIX(8UI)
+
+ SET_BY_SUFFIX(16I)
+ SET_BY_SUFFIX(16UI)
+
+ SET_BY_SUFFIX(32I)
+ SET_BY_SUFFIX(32UI)
+
+#undef SET_BY_SUFFIX
+
+ //////
+
+ SET_COPY_DECAY( RGB565, R8, RG8, RGB565, MAX, Luminance8, MAX, MAX)
+ SET_COPY_DECAY( RGBA4, R8, RG8, RGB565, RGBA4, Luminance8, Alpha8, Luminance8Alpha8)
+ SET_COPY_DECAY( RGB5_A1, R8, RG8, RGB565, RGB5_A1, Luminance8, Alpha8, Luminance8Alpha8)
+ SET_COPY_DECAY( RGB10_A2, R8, RG8, RGB8, RGB10_A2, Luminance8, Alpha8, MAX)
+
+ SET_COPY_DECAY(RGB10_A2UI, R8UI, RG8UI, RGB8UI, RGB10_A2UI, MAX, MAX, MAX)
+
+ SET_COPY_DECAY(SRGB8_ALPHA8, MAX, MAX, MAX, SRGB8_ALPHA8, MAX, Alpha8, MAX)
+
+ SET_COPY_DECAY(R11F_G11F_B10F, R16F, RG16F, R11F_G11F_B10F, MAX, Luminance16F, MAX, MAX)
+
+#undef SET_COPY_DECAY
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+bool gAreFormatTablesInitialized = false;
+
+static void
+EnsureInitFormatTables(const StaticMutexAutoLock&) // Prove that you locked it!
+{
+ if (MOZ_LIKELY(gAreFormatTablesInitialized))
+ return;
+
+ gAreFormatTablesInitialized = true;
+
+ InitCompressedFormatInfo();
+ InitFormatInfo();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Public funcs
+
+StaticMutex gFormatMapMutex;
+
+const FormatInfo*
+GetFormat(EffectiveFormat format)
+{
+ StaticMutexAutoLock lock(gFormatMapMutex);
+ EnsureInitFormatTables(lock);
+
+ return GetFormatInfo_NoLock(format);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+const FormatInfo*
+FormatInfo::GetCopyDecayFormat(UnsizedFormat uf) const
+{
+ return FindOrNull(this->copyDecayFormats, uf);
+}
+
+bool
+GetBytesPerPixel(const PackingInfo& packing, uint8_t* const out_bytes)
+{
+ uint8_t bytesPerChannel;
+
+ switch (packing.type) {
+ case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
+ case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
+ case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
+ *out_bytes = 2;
+ return true;
+
+ case LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV:
+ case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
+ case LOCAL_GL_UNSIGNED_INT_24_8:
+ case LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV:
+ *out_bytes = 4;
+ return true;
+
+ case LOCAL_GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
+ *out_bytes = 8;
+ return true;
+
+ // Alright, that's all the fixed-size unpackTypes.
+
+ case LOCAL_GL_BYTE:
+ case LOCAL_GL_UNSIGNED_BYTE:
+ bytesPerChannel = 1;
+ break;
+
+ case LOCAL_GL_SHORT:
+ case LOCAL_GL_UNSIGNED_SHORT:
+ case LOCAL_GL_HALF_FLOAT:
+ case LOCAL_GL_HALF_FLOAT_OES:
+ bytesPerChannel = 2;
+ break;
+
+ case LOCAL_GL_INT:
+ case LOCAL_GL_UNSIGNED_INT:
+ case LOCAL_GL_FLOAT:
+ bytesPerChannel = 4;
+ break;
+
+ default:
+ return false;
+ }
+
+ uint8_t channels;
+
+ switch (packing.format) {
+ case LOCAL_GL_RED:
+ case LOCAL_GL_RED_INTEGER:
+ case LOCAL_GL_LUMINANCE:
+ case LOCAL_GL_ALPHA:
+ case LOCAL_GL_DEPTH_COMPONENT:
+ channels = 1;
+ break;
+
+ case LOCAL_GL_RG:
+ case LOCAL_GL_RG_INTEGER:
+ case LOCAL_GL_LUMINANCE_ALPHA:
+ channels = 2;
+ break;
+
+ case LOCAL_GL_RGB:
+ case LOCAL_GL_RGB_INTEGER:
+ case LOCAL_GL_SRGB:
+ channels = 3;
+ break;
+
+ case LOCAL_GL_BGRA:
+ case LOCAL_GL_RGBA:
+ case LOCAL_GL_RGBA_INTEGER:
+ case LOCAL_GL_SRGB_ALPHA:
+ channels = 4;
+ break;
+
+ default:
+ return false;
+ }
+
+ *out_bytes = bytesPerChannel * channels;
+ return true;
+}
+
+uint8_t
+BytesPerPixel(const PackingInfo& packing)
+{
+ uint8_t ret;
+ if (MOZ_LIKELY(GetBytesPerPixel(packing, &ret)))
+ return ret;
+
+ gfxCriticalError() << "Bad `packing`: " << gfx::hexa(packing.format) << ", "
+ << gfx::hexa(packing.type);
+ MOZ_CRASH("Bad `packing`.");
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+// FormatUsageAuthority
+
+bool
+FormatUsageInfo::IsUnpackValid(const PackingInfo& key,
+ const DriverUnpackInfo** const out_value) const
+{
+ auto itr = validUnpacks.find(key);
+ if (itr == validUnpacks.end())
+ return false;
+
+ *out_value = &(itr->second);
+ return true;
+}
+
+void
+FormatUsageInfo::ResolveMaxSamples(gl::GLContext* gl)
+{
+ MOZ_ASSERT(!this->maxSamplesKnown);
+ MOZ_ASSERT(this->maxSamples == 0);
+ MOZ_ASSERT(gl->IsCurrent());
+
+ this->maxSamplesKnown = true;
+
+ const GLenum internalFormat = this->format->sizedFormat;
+ if (!internalFormat)
+ return;
+
+ if (!gl->IsSupported(gl::GLFeature::internalformat_query))
+ return; // Leave it at 0.
+
+ GLint maxSamplesGL = 0;
+ gl->fGetInternalformativ(LOCAL_GL_RENDERBUFFER, internalFormat, LOCAL_GL_SAMPLES, 1,
+ &maxSamplesGL);
+
+ this->maxSamples = maxSamplesGL;
+}
+
+////////////////////////////////////////
+
+static void
+AddSimpleUnsized(FormatUsageAuthority* fua, GLenum unpackFormat, GLenum unpackType,
+ EffectiveFormat effFormat)
+{
+ auto usage = fua->EditUsage(effFormat);
+ usage->isFilterable = true;
+
+ const PackingInfo pi = {unpackFormat, unpackType};
+ const DriverUnpackInfo dui = {unpackFormat, unpackFormat, unpackType};
+ fua->AddTexUnpack(usage, pi, dui);
+
+ fua->AllowUnsizedTexFormat(pi, usage);
+};
+
+
+/*static*/ const GLint FormatUsageInfo::kLuminanceSwizzleRGBA[4] = { LOCAL_GL_RED,
+ LOCAL_GL_RED,
+ LOCAL_GL_RED,
+ LOCAL_GL_ONE };
+/*static*/ const GLint FormatUsageInfo::kAlphaSwizzleRGBA[4] = { LOCAL_GL_ZERO,
+ LOCAL_GL_ZERO,
+ LOCAL_GL_ZERO,
+ LOCAL_GL_RED };
+/*static*/ const GLint FormatUsageInfo::kLumAlphaSwizzleRGBA[4] = { LOCAL_GL_RED,
+ LOCAL_GL_RED,
+ LOCAL_GL_RED,
+ LOCAL_GL_GREEN };
+
+static bool
+AddLegacyFormats_LA8(FormatUsageAuthority* fua, gl::GLContext* gl)
+{
+ if (gl->IsCoreProfile()) {
+ if (!gl->IsSupported(gl::GLFeature::texture_swizzle))
+ return false;
+
+ PackingInfo pi;
+ DriverUnpackInfo dui;
+
+ const auto fnAdd = [fua, &pi, &dui](EffectiveFormat effFormat,
+ const GLint* swizzle)
+ {
+ auto usage = fua->EditUsage(effFormat);
+ usage->isFilterable = true;
+ usage->textureSwizzleRGBA = swizzle;
+
+ fua->AddTexUnpack(usage, pi, dui);
+
+ fua->AllowUnsizedTexFormat(pi, usage);
+ };
+
+ pi = {LOCAL_GL_LUMINANCE, LOCAL_GL_UNSIGNED_BYTE};
+ dui = {LOCAL_GL_R8, LOCAL_GL_RED, LOCAL_GL_UNSIGNED_BYTE};
+ fnAdd(EffectiveFormat::Luminance8, FormatUsageInfo::kLuminanceSwizzleRGBA);
+
+ pi = {LOCAL_GL_ALPHA, LOCAL_GL_UNSIGNED_BYTE};
+ dui = {LOCAL_GL_R8, LOCAL_GL_RED, LOCAL_GL_UNSIGNED_BYTE};
+ fnAdd(EffectiveFormat::Alpha8, FormatUsageInfo::kAlphaSwizzleRGBA);
+
+ pi = {LOCAL_GL_LUMINANCE_ALPHA, LOCAL_GL_UNSIGNED_BYTE};
+ dui = {LOCAL_GL_RG8, LOCAL_GL_RG, LOCAL_GL_UNSIGNED_BYTE};
+ fnAdd(EffectiveFormat::Luminance8Alpha8, FormatUsageInfo::kLumAlphaSwizzleRGBA);
+ } else {
+ AddSimpleUnsized(fua, LOCAL_GL_LUMINANCE , LOCAL_GL_UNSIGNED_BYTE, EffectiveFormat::Luminance8 );
+ AddSimpleUnsized(fua, LOCAL_GL_ALPHA , LOCAL_GL_UNSIGNED_BYTE, EffectiveFormat::Alpha8 );
+ AddSimpleUnsized(fua, LOCAL_GL_LUMINANCE_ALPHA, LOCAL_GL_UNSIGNED_BYTE, EffectiveFormat::Luminance8Alpha8);
+ }
+
+ return true;
+}
+
+static bool
+AddUnsizedFormats(FormatUsageAuthority* fua, gl::GLContext* gl)
+{
+ // GLES 2.0.25, p63, Table 3.4
+ AddSimpleUnsized(fua, LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE , EffectiveFormat::RGBA8 );
+ AddSimpleUnsized(fua, LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_SHORT_4_4_4_4, EffectiveFormat::RGBA4 );
+ AddSimpleUnsized(fua, LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_SHORT_5_5_5_1, EffectiveFormat::RGB5_A1);
+ AddSimpleUnsized(fua, LOCAL_GL_RGB , LOCAL_GL_UNSIGNED_BYTE , EffectiveFormat::RGB8 );
+ AddSimpleUnsized(fua, LOCAL_GL_RGB , LOCAL_GL_UNSIGNED_SHORT_5_6_5 , EffectiveFormat::RGB565 );
+
+ // L, A, LA
+ return AddLegacyFormats_LA8(fua, gl);
+}
+
+void
+FormatUsageInfo::SetRenderable()
+{
+ this->isRenderable = true;
+
+#ifdef DEBUG
+ const auto format = this->format;
+ if (format->IsColorFormat()) {
+ const auto& map = format->copyDecayFormats;
+ const auto itr = map.find(format->unsizedFormat);
+ MOZ_ASSERT(itr != map.end(), "Renderable formats must be in copyDecayFormats.");
+ MOZ_ASSERT(itr->second == format);
+ }
+#endif
+}
+
+UniquePtr<FormatUsageAuthority>
+FormatUsageAuthority::CreateForWebGL1(gl::GLContext* gl)
+{
+ UniquePtr<FormatUsageAuthority> ret(new FormatUsageAuthority);
+ const auto ptr = ret.get();
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Usages
+
+ const auto fnSet = [ptr](EffectiveFormat effFormat, bool isRenderable,
+ bool isFilterable)
+ {
+ MOZ_ASSERT(!ptr->GetUsage(effFormat));
+
+ auto usage = ptr->EditUsage(effFormat);
+ usage->isFilterable = isFilterable;
+
+ if (isRenderable) {
+ usage->SetRenderable();
+ }
+ };
+
+ // GLES 2.0.25, p117, Table 4.5
+ // RGBA8 is made renderable in WebGL 1.0, "Framebuffer Object Attachments"
+ // render filter
+ // able able
+ fnSet(EffectiveFormat::RGBA8 , true, true);
+ fnSet(EffectiveFormat::RGBA4 , true, true);
+ fnSet(EffectiveFormat::RGB5_A1, true, true);
+ fnSet(EffectiveFormat::RGB565 , true, true);
+
+ // RGB8 is not guaranteed to be renderable, but we should allow it for web-compat.
+ // Min-capability mode should mark this as non-renderable.
+ fnSet(EffectiveFormat::RGB8, true, true);
+
+ fnSet(EffectiveFormat::Luminance8Alpha8, false, true);
+ fnSet(EffectiveFormat::Luminance8 , false, true);
+ fnSet(EffectiveFormat::Alpha8 , false, true);
+
+ fnSet(EffectiveFormat::DEPTH_COMPONENT16, true, false);
+ fnSet(EffectiveFormat::STENCIL_INDEX8 , true, false);
+
+ // Added in WebGL 1.0 spec:
+ fnSet(EffectiveFormat::DEPTH24_STENCIL8, true, false);
+
+ ////////////////////////////////////
+ // RB formats
+
+#define FOO(x) ptr->AllowRBFormat(LOCAL_GL_ ## x, ptr->GetUsage(EffectiveFormat::x))
+
+ FOO(RGBA4 );
+ FOO(RGB5_A1 );
+ FOO(RGB565 );
+ FOO(DEPTH_COMPONENT16);
+ FOO(STENCIL_INDEX8 );
+ //FOO(DEPTH24_STENCIL8 ); // WebGL 1 uses DEPTH_STENCIL instead of DEPTH24_STENCIL8.
+
+#undef FOO
+
+ ptr->AllowRBFormat(LOCAL_GL_DEPTH_STENCIL,
+ ptr->GetUsage(EffectiveFormat::DEPTH24_STENCIL8));
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ if (!AddUnsizedFormats(ptr, gl))
+ return nullptr;
+
+ return Move(ret);
+}
+
+UniquePtr<FormatUsageAuthority>
+FormatUsageAuthority::CreateForWebGL2(gl::GLContext* gl)
+{
+ UniquePtr<FormatUsageAuthority> ret(new FormatUsageAuthority);
+ const auto ptr = ret.get();
+
+ ////////////////////////////////////////////////////////////////////////////
+ // GLES 3.0.4 p111-113
+
+ const auto fnAddSizedUnpack = [ptr](EffectiveFormat effFormat, GLenum internalFormat,
+ GLenum unpackFormat, GLenum unpackType)
+ {
+ auto usage = ptr->EditUsage(effFormat);
+
+ const PackingInfo pi = {unpackFormat, unpackType};
+ const DriverUnpackInfo dui = {internalFormat, unpackFormat, unpackType};
+ ptr->AddTexUnpack(usage, pi, dui);
+ };
+
+#define FOO(x) EffectiveFormat::x, LOCAL_GL_ ## x
+
+ // RGBA
+ fnAddSizedUnpack(FOO(RGBA8 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGBA4 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_SHORT_4_4_4_4 );
+ fnAddSizedUnpack(FOO(RGBA4 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGB5_A1 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_SHORT_5_5_5_1 );
+ fnAddSizedUnpack(FOO(RGB5_A1 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGB5_A1 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV);
+ fnAddSizedUnpack(FOO(SRGB8_ALPHA8), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGBA8_SNORM ), LOCAL_GL_RGBA, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(RGB10_A2 ), LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV);
+ fnAddSizedUnpack(FOO(RGBA16F ), LOCAL_GL_RGBA, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(RGBA16F ), LOCAL_GL_RGBA, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(RGBA32F ), LOCAL_GL_RGBA, LOCAL_GL_FLOAT );
+
+ // RGBA_INTEGER
+ fnAddSizedUnpack(FOO(RGBA8UI ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGBA8I ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(RGBA16UI ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_UNSIGNED_SHORT );
+ fnAddSizedUnpack(FOO(RGBA16I ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_SHORT );
+ fnAddSizedUnpack(FOO(RGBA32UI ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(RGBA32I ), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_INT );
+ fnAddSizedUnpack(FOO(RGB10_A2UI), LOCAL_GL_RGBA_INTEGER, LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV);
+
+ // RGB
+ fnAddSizedUnpack(FOO(RGB8 ), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(SRGB8 ), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGB565 ), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_SHORT_5_6_5 );
+ fnAddSizedUnpack(FOO(RGB565 ), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGB8_SNORM ), LOCAL_GL_RGB, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(R11F_G11F_B10F), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV);
+ fnAddSizedUnpack(FOO(R11F_G11F_B10F), LOCAL_GL_RGB, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(R11F_G11F_B10F), LOCAL_GL_RGB, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(RGB16F ), LOCAL_GL_RGB, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(RGB16F ), LOCAL_GL_RGB, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(RGB9_E5 ), LOCAL_GL_RGB, LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV );
+ fnAddSizedUnpack(FOO(RGB9_E5 ), LOCAL_GL_RGB, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(RGB9_E5 ), LOCAL_GL_RGB, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(RGB32F ), LOCAL_GL_RGB, LOCAL_GL_FLOAT );
+
+ // RGB_INTEGER
+ fnAddSizedUnpack(FOO(RGB8UI ), LOCAL_GL_RGB_INTEGER, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RGB8I ), LOCAL_GL_RGB_INTEGER, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(RGB16UI), LOCAL_GL_RGB_INTEGER, LOCAL_GL_UNSIGNED_SHORT);
+ fnAddSizedUnpack(FOO(RGB16I ), LOCAL_GL_RGB_INTEGER, LOCAL_GL_SHORT );
+ fnAddSizedUnpack(FOO(RGB32UI), LOCAL_GL_RGB_INTEGER, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(RGB32I ), LOCAL_GL_RGB_INTEGER, LOCAL_GL_INT );
+
+ // RG
+ fnAddSizedUnpack(FOO(RG8 ), LOCAL_GL_RG, LOCAL_GL_UNSIGNED_BYTE);
+ fnAddSizedUnpack(FOO(RG8_SNORM), LOCAL_GL_RG, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(RG16F ), LOCAL_GL_RG, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(RG16F ), LOCAL_GL_RG, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(RG32F ), LOCAL_GL_RG, LOCAL_GL_FLOAT );
+
+ // RG_INTEGER
+ fnAddSizedUnpack(FOO(RG8UI ), LOCAL_GL_RG_INTEGER, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(RG8I ), LOCAL_GL_RG_INTEGER, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(RG16UI), LOCAL_GL_RG_INTEGER, LOCAL_GL_UNSIGNED_SHORT);
+ fnAddSizedUnpack(FOO(RG16I ), LOCAL_GL_RG_INTEGER, LOCAL_GL_SHORT );
+ fnAddSizedUnpack(FOO(RG32UI), LOCAL_GL_RG_INTEGER, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(RG32I ), LOCAL_GL_RG_INTEGER, LOCAL_GL_INT );
+
+ // RED
+ fnAddSizedUnpack(FOO(R8 ), LOCAL_GL_RED, LOCAL_GL_UNSIGNED_BYTE);
+ fnAddSizedUnpack(FOO(R8_SNORM), LOCAL_GL_RED, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(R16F ), LOCAL_GL_RED, LOCAL_GL_HALF_FLOAT );
+ fnAddSizedUnpack(FOO(R16F ), LOCAL_GL_RED, LOCAL_GL_FLOAT );
+ fnAddSizedUnpack(FOO(R32F ), LOCAL_GL_RED, LOCAL_GL_FLOAT );
+
+ // RED_INTEGER
+ fnAddSizedUnpack(FOO(R8UI ), LOCAL_GL_RED_INTEGER, LOCAL_GL_UNSIGNED_BYTE );
+ fnAddSizedUnpack(FOO(R8I ), LOCAL_GL_RED_INTEGER, LOCAL_GL_BYTE );
+ fnAddSizedUnpack(FOO(R16UI), LOCAL_GL_RED_INTEGER, LOCAL_GL_UNSIGNED_SHORT);
+ fnAddSizedUnpack(FOO(R16I ), LOCAL_GL_RED_INTEGER, LOCAL_GL_SHORT );
+ fnAddSizedUnpack(FOO(R32UI), LOCAL_GL_RED_INTEGER, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(R32I ), LOCAL_GL_RED_INTEGER, LOCAL_GL_INT );
+
+ // DEPTH_COMPONENT
+ fnAddSizedUnpack(FOO(DEPTH_COMPONENT16 ), LOCAL_GL_DEPTH_COMPONENT, LOCAL_GL_UNSIGNED_SHORT);
+ fnAddSizedUnpack(FOO(DEPTH_COMPONENT16 ), LOCAL_GL_DEPTH_COMPONENT, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(DEPTH_COMPONENT24 ), LOCAL_GL_DEPTH_COMPONENT, LOCAL_GL_UNSIGNED_INT );
+ fnAddSizedUnpack(FOO(DEPTH_COMPONENT32F), LOCAL_GL_DEPTH_COMPONENT, LOCAL_GL_FLOAT );
+
+ // DEPTH_STENCIL
+ fnAddSizedUnpack(FOO(DEPTH24_STENCIL8 ), LOCAL_GL_DEPTH_STENCIL, LOCAL_GL_UNSIGNED_INT_24_8 );
+ fnAddSizedUnpack(FOO(DEPTH32F_STENCIL8), LOCAL_GL_DEPTH_STENCIL, LOCAL_GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
+
+#undef FOO
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ // For renderable, see GLES 3.0.4, p212 "Framebuffer Completeness"
+ // For filterable, see GLES 3.0.4, p161 "...a texture is complete unless..."
+
+ const auto fnAllowES3TexFormat = [ptr](GLenum sizedFormat, EffectiveFormat effFormat,
+ bool isRenderable, bool isFilterable)
+ {
+ auto usage = ptr->EditUsage(effFormat);
+ usage->isFilterable = isFilterable;
+
+ if (isRenderable) {
+ usage->SetRenderable();
+ }
+
+ ptr->AllowSizedTexFormat(sizedFormat, usage);
+
+ if (isRenderable) {
+ ptr->AllowRBFormat(sizedFormat, usage);
+ }
+ };
+
+#define FOO(x) LOCAL_GL_ ## x, EffectiveFormat::x
+
+ // GLES 3.0.4, p128-129 "Required Texture Formats"
+ // GLES 3.0.4, p130-132, table 3.13
+ // render filter
+ // able able
+ fnAllowES3TexFormat(FOO(R8 ), true , true );
+ fnAllowES3TexFormat(FOO(R8_SNORM ), false, true );
+ fnAllowES3TexFormat(FOO(RG8 ), true , true );
+ fnAllowES3TexFormat(FOO(RG8_SNORM ), false, true );
+ fnAllowES3TexFormat(FOO(RGB8 ), true , true );
+ fnAllowES3TexFormat(FOO(RGB8_SNORM ), false, true );
+ fnAllowES3TexFormat(FOO(RGB565 ), true , true );
+ fnAllowES3TexFormat(FOO(RGBA4 ), true , true );
+ fnAllowES3TexFormat(FOO(RGB5_A1 ), true , true );
+ fnAllowES3TexFormat(FOO(RGBA8 ), true , true );
+ fnAllowES3TexFormat(FOO(RGBA8_SNORM), false, true );
+ fnAllowES3TexFormat(FOO(RGB10_A2 ), true , true );
+ fnAllowES3TexFormat(FOO(RGB10_A2UI ), true , false);
+
+ fnAllowES3TexFormat(FOO(SRGB8 ), false, true);
+ fnAllowES3TexFormat(FOO(SRGB8_ALPHA8), true , true);
+
+ fnAllowES3TexFormat(FOO(R16F ), false, true);
+ fnAllowES3TexFormat(FOO(RG16F ), false, true);
+ fnAllowES3TexFormat(FOO(RGB16F ), false, true);
+ fnAllowES3TexFormat(FOO(RGBA16F), false, true);
+
+ fnAllowES3TexFormat(FOO(R32F ), false, false);
+ fnAllowES3TexFormat(FOO(RG32F ), false, false);
+ fnAllowES3TexFormat(FOO(RGB32F ), false, false);
+ fnAllowES3TexFormat(FOO(RGBA32F), false, false);
+
+ fnAllowES3TexFormat(FOO(R11F_G11F_B10F), false, true);
+ fnAllowES3TexFormat(FOO(RGB9_E5 ), false, true);
+
+ fnAllowES3TexFormat(FOO(R8I ), true, false);
+ fnAllowES3TexFormat(FOO(R8UI ), true, false);
+ fnAllowES3TexFormat(FOO(R16I ), true, false);
+ fnAllowES3TexFormat(FOO(R16UI), true, false);
+ fnAllowES3TexFormat(FOO(R32I ), true, false);
+ fnAllowES3TexFormat(FOO(R32UI), true, false);
+
+ fnAllowES3TexFormat(FOO(RG8I ), true, false);
+ fnAllowES3TexFormat(FOO(RG8UI ), true, false);
+ fnAllowES3TexFormat(FOO(RG16I ), true, false);
+ fnAllowES3TexFormat(FOO(RG16UI), true, false);
+ fnAllowES3TexFormat(FOO(RG32I ), true, false);
+ fnAllowES3TexFormat(FOO(RG32UI), true, false);
+
+ fnAllowES3TexFormat(FOO(RGB8I ), false, false);
+ fnAllowES3TexFormat(FOO(RGB8UI ), false, false);
+ fnAllowES3TexFormat(FOO(RGB16I ), false, false);
+ fnAllowES3TexFormat(FOO(RGB16UI), false, false);
+ fnAllowES3TexFormat(FOO(RGB32I ), false, false);
+ fnAllowES3TexFormat(FOO(RGB32UI), false, false);
+
+ fnAllowES3TexFormat(FOO(RGBA8I ), true, false);
+ fnAllowES3TexFormat(FOO(RGBA8UI ), true, false);
+ fnAllowES3TexFormat(FOO(RGBA16I ), true, false);
+ fnAllowES3TexFormat(FOO(RGBA16UI), true, false);
+ fnAllowES3TexFormat(FOO(RGBA32I ), true, false);
+ fnAllowES3TexFormat(FOO(RGBA32UI), true, false);
+
+ // GLES 3.0.4, p133, table 3.14
+ fnAllowES3TexFormat(FOO(DEPTH_COMPONENT16 ), true, false);
+ fnAllowES3TexFormat(FOO(DEPTH_COMPONENT24 ), true, false);
+ fnAllowES3TexFormat(FOO(DEPTH_COMPONENT32F), true, false);
+ fnAllowES3TexFormat(FOO(DEPTH24_STENCIL8 ), true, false);
+ fnAllowES3TexFormat(FOO(DEPTH32F_STENCIL8 ), true, false);
+
+#undef FOO
+
+ // GLES 3.0.4, p206, "Required Renderbuffer Formats":
+ // "Implementations are also required to support STENCIL_INDEX8. Requesting this
+ // internal format for a renderbuffer will allocate at least 8 stencil bit planes."
+
+ auto usage = ptr->EditUsage(EffectiveFormat::STENCIL_INDEX8);
+ usage->SetRenderable();
+ ptr->AllowRBFormat(LOCAL_GL_STENCIL_INDEX8, usage);
+
+ ////////////////
+ // Legacy formats
+
+ if (!AddUnsizedFormats(ptr, gl))
+ return nullptr;
+
+ ptr->AllowRBFormat(LOCAL_GL_DEPTH_STENCIL,
+ ptr->GetUsage(EffectiveFormat::DEPTH24_STENCIL8));
+
+ if (gfxPrefs::WebGL2CompatMode()) {
+ AddSimpleUnsized(ptr, LOCAL_GL_RGBA, LOCAL_GL_FLOAT, EffectiveFormat::RGBA32F);
+ AddSimpleUnsized(ptr, LOCAL_GL_RGB , LOCAL_GL_FLOAT, EffectiveFormat::RGB32F );
+
+ AddSimpleUnsized(ptr, LOCAL_GL_RGBA, LOCAL_GL_HALF_FLOAT_OES, EffectiveFormat::RGBA16F);
+ AddSimpleUnsized(ptr, LOCAL_GL_RGB , LOCAL_GL_HALF_FLOAT_OES, EffectiveFormat::RGB16F );
+ }
+
+ ////////////////////////////////////
+
+ return Move(ret);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+void
+FormatUsageAuthority::AddTexUnpack(FormatUsageInfo* usage, const PackingInfo& pi,
+ const DriverUnpackInfo& dui)
+{
+ // Don't AlwaysInsert here, since we'll see duplicates from sized and unsized formats.
+ auto res = usage->validUnpacks.insert({ pi, dui });
+ auto itr = res.first;
+
+ if (!usage->idealUnpack) {
+ // First one!
+ usage->idealUnpack = &(itr->second);
+ }
+
+ mValidTexUnpackFormats.insert(pi.format);
+ mValidTexUnpackTypes.insert(pi.type);
+}
+
+static bool
+Contains(const std::set<GLenum>& set, GLenum key)
+{
+ return set.find(key) != set.end();
+}
+
+bool
+FormatUsageAuthority::IsInternalFormatEnumValid(GLenum internalFormat) const
+{
+ return Contains(mValidTexInternalFormats, internalFormat);
+}
+
+bool
+FormatUsageAuthority::AreUnpackEnumsValid(GLenum unpackFormat, GLenum unpackType) const
+{
+ return (Contains(mValidTexUnpackFormats, unpackFormat) &&
+ Contains(mValidTexUnpackTypes, unpackType));
+}
+
+////////////////////
+
+void
+FormatUsageAuthority::AllowRBFormat(GLenum sizedFormat, const FormatUsageInfo* usage)
+{
+ MOZ_ASSERT(!usage->format->compression);
+ MOZ_ASSERT(usage->format->sizedFormat);
+ MOZ_ASSERT(usage->IsRenderable());
+
+ AlwaysInsert(mRBFormatMap, sizedFormat, usage);
+}
+
+void
+FormatUsageAuthority::AllowSizedTexFormat(GLenum sizedFormat,
+ const FormatUsageInfo* usage)
+{
+ if (usage->format->compression) {
+ MOZ_ASSERT(usage->isFilterable, "Compressed formats should be filterable.");
+ } else {
+ MOZ_ASSERT(usage->validUnpacks.size() && usage->idealUnpack,
+ "AddTexUnpack() first.");
+ }
+
+ AlwaysInsert(mSizedTexFormatMap, sizedFormat, usage);
+
+ mValidTexInternalFormats.insert(sizedFormat);
+}
+
+void
+FormatUsageAuthority::AllowUnsizedTexFormat(const PackingInfo& pi,
+ const FormatUsageInfo* usage)
+{
+ MOZ_ASSERT(!usage->format->compression);
+ MOZ_ASSERT(usage->validUnpacks.size() && usage->idealUnpack, "AddTexUnpack() first.");
+
+ AlwaysInsert(mUnsizedTexFormatMap, pi, usage);
+
+ mValidTexInternalFormats.insert(pi.format);
+ mValidTexUnpackFormats.insert(pi.format);
+ mValidTexUnpackTypes.insert(pi.type);
+}
+
+const FormatUsageInfo*
+FormatUsageAuthority::GetRBUsage(GLenum sizedFormat) const
+{
+ return FindOrNull(mRBFormatMap, sizedFormat);
+}
+
+const FormatUsageInfo*
+FormatUsageAuthority::GetSizedTexUsage(GLenum sizedFormat) const
+{
+ return FindOrNull(mSizedTexFormatMap, sizedFormat);
+}
+
+const FormatUsageInfo*
+FormatUsageAuthority::GetUnsizedTexUsage(const PackingInfo& pi) const
+{
+ return FindOrNull(mUnsizedTexFormatMap, pi);
+}
+
+FormatUsageInfo*
+FormatUsageAuthority::EditUsage(EffectiveFormat format)
+{
+ auto itr = mUsageMap.find(format);
+
+ if (itr == mUsageMap.end()) {
+ const FormatInfo* formatInfo = GetFormat(format);
+ MOZ_RELEASE_ASSERT(formatInfo, "GFX: no format info set.");
+
+ FormatUsageInfo usage(formatInfo);
+
+ auto res = mUsageMap.insert({ format, usage });
+ DebugOnly<bool> didInsert = res.second;
+ MOZ_ASSERT(didInsert);
+
+ itr = res.first;
+ }
+
+ return &(itr->second);
+}
+
+const FormatUsageInfo*
+FormatUsageAuthority::GetUsage(EffectiveFormat format) const
+{
+ auto itr = mUsageMap.find(format);
+ if (itr == mUsageMap.end())
+ return nullptr;
+
+ return &(itr->second);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace webgl
+} // namespace mozilla