未成功引ncnn

+// OpenCVVideoProcessor.kt
+package io.livekit.android.track.processing.video
+
+import android.graphics.Bitmap
+import android.view.Surface
+import io.livekit.android.room.track.video.NoDropVideoProcessor
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.launch
+import livekit.org.webrtc.EglBase
+import livekit.org.webrtc.EglRenderer
+import livekit.org.webrtc.GlUtil
+import livekit.org.webrtc.SurfaceTextureHelper
+import livekit.org.webrtc.VideoFrame
+import livekit.org.webrtc.VideoSink
+import org.opencv.android.Utils
+import org.opencv.core.CvType
+import org.opencv.core.Mat
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.roundToInt
+
+/**
+ * OpenCV-based video processor using ncnn RVM for real-time video processing.
+ * Inherits from NoDropVideoProcessor to ensure frames are processed even when not published.
+ */
+class OpenCVVideoProcessor(
+    private val eglBase: EglBase,
+    dispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : NoDropVideoProcessor() {
+
+    private var targetSink: VideoSink? = null
+    private val surfaceTextureHelper = SurfaceTextureHelper.create("OpenCVProcessor", eglBase.eglBaseContext)
+    private val surface = Surface(surfaceTextureHelper.surfaceTexture)
+    
+    private val eglRenderer = EglRenderer(OpenCVVideoProcessor::class.java.simpleName)
+        .apply {
+            init(eglBase.eglBaseContext, EglBase.CONFIG_PLAIN, null)
+            createEglSurface(surface)
+        }
+
+    private val scope = CoroutineScope(dispatcher)
+    private val taskFlow = MutableSharedFlow<VideoFrame>(
+        replay = 0,
+        extraBufferCapacity = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+
+    // RVM ncnn instance
+    private val rvmNcnn = com.tencent.rvmncnn.RVMNcnn()
+
+    private var lastRotation = 0
+    private var lastWidth = 0
+    private var lastHeight = 0
+
+    /**
+     * Enable or disable RVM processing
+     */
+    var enabled: Boolean = true
+
+    /**
+     * Background image to use for virtual background
+     * If null, will use default background
+     */
+    var backgroundImage: Bitmap? = null
+
+    init {
+        // Initialize processing pipeline
+        scope.launch {
+            taskFlow.collect { frame ->
+                processFrame(frame)
+                frame.release()
+            }
+        }
+    }
+
+    override fun onCapturerStarted(started: Boolean) {
+        if (started) {
+            surfaceTextureHelper.stopListening()
+            surfaceTextureHelper.startListening { frame ->
+                targetSink?.onFrame(frame)
+            }
+        }
+    }
+
+    override fun onCapturerStopped() {
+        surfaceTextureHelper.stopListening()
+    }
+
+    override fun onFrameCaptured(frame: VideoFrame) {
+        // If disabled, just pass through
+        if (!enabled) {
+            targetSink?.onFrame(frame)
+            return
+        }
+
+        try {
+            frame.retain()
+        } catch (e: Exception) {
+            return
+        }
+
+        // Submit frame for processing
+        if (!taskFlow.tryEmit(frame)) {
+            frame.release()
+        }
+    }
+
+    override fun setSink(sink: VideoSink?) {
+        targetSink = sink
+    }
+
+    private fun processFrame(frame: VideoFrame) {
+        if (lastRotation != frame.rotation || 
+            lastWidth != frame.rotatedWidth || 
+            lastHeight != frame.rotatedHeight) {
+            
+            surfaceTextureHelper.setTextureSize(frame.rotatedWidth, frame.rotatedHeight)
+            lastRotation = frame.rotation
+            lastWidth = frame.rotatedWidth
+            lastHeight = frame.rotatedHeight
+        }
+
+        frame.retain()
+        surfaceTextureHelper.handler.post {
+            try {
+                // Convert VideoFrame to OpenCV Mat
+                val rgbaMat = videoFrameToMat(frame)
+                
+                if (rgbaMat != null && !rgbaMat.empty()) {
+                    // Process with RVM
+                    val success = rvmNcnn.processFrame(
+                        rgbaMat.nativeObjAddr,
+                        rgbaMat.cols(),
+                        rgbaMat.rows(),
+                        frame.rotation
+                    )
+                    
+                    if (success) {
+                        // Convert processed Mat back to texture and render
+                        val processedFrame = matToVideoFrame(rgbaMat, frame)
+                        eglRenderer.onFrame(processedFrame)
+                        processedFrame.release()
+                    } else {
+                        // If processing failed, pass through original frame
+                        eglRenderer.onFrame(frame)
+                    }
+                    
+                    rgbaMat.release()
+                } else {
+                    eglRenderer.onFrame(frame)
+                }
+            } catch (e: Exception) {
+                // Fallback to original frame on error
+                eglRenderer.onFrame(frame)
+            }
+            frame.release()
+        }
+    }
+
+    private fun videoFrameToMat(frame: VideoFrame): Mat? {
+        return try {
+            val i420Buffer = frame.buffer.toI420()
+            val yPlane = i420Buffer.dataY
+            val uPlane = i420Buffer.dataU
+            val vPlane = i420Buffer.dataV
+            
+            val yRowStride = i420Buffer.strideY
+            val uvRowStride = i420Buffer.strideU
+            val uvPixelStride = i420Buffer.strideU // Simplified
+            
+            val width = i420Buffer.width
+            val height = i420Buffer.height
+            
+            // Convert I420 to RGBA
+            val rgbaMat = Mat(height, width, CvType.CV_8UC4)
+            
+            // This is a simplified conversion - in production you'd want a proper YUV to RGBA conversion
+            // For now, we'll create a placeholder implementation
+            convertI420ToRGBA(yPlane, uPlane, vPlane, yRowStride, uvRowStride, uvPixelStride, width, height, rgbaMat)
+            
+            i420Buffer.release()
+            rgbaMat
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun convertI420ToRGBA(
+        yPlane: ByteBuffer,
+        uPlane: ByteBuffer,
+        vPlane: ByteBuffer,
+        yRowStride: Int,
+        uvRowStride: Int,
+        uvPixelStride: Int,
+        width: Int,
+        height: Int,
+        rgbaMat: Mat
+    ) {
+        // Placeholder implementation - you'd need proper YUV to RGBA conversion
+        // This is a simplified version that just creates a test pattern
+        val rgbaData = ByteArray(width * height * 4)
+        var index = 0
+        
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val yIndex = (y * yRowStride) + x
+                val uvIndex = ((y / 2) * uvRowStride) + ((x / 2) * uvPixelStride)
+                
+                val yValue = yPlane[yIndex].toInt() and 0xFF
+                val uValue = uPlane[uvIndex].toInt() and 0xFF
+                val vValue = vPlane[uvIndex].toInt() and 0xFF
+                
+                // Simple YUV to RGB conversion (simplified)
+                val r = (1.164 * (yValue - 16) + 1.596 * (vValue - 128)).toInt().coerceIn(0, 255)
+                val g = (1.164 * (yValue - 16) - 0.813 * (vValue - 128) - 0.391 * (uValue - 128)).toInt().coerceIn(0, 255)
+                val b = (1.164 * (yValue - 16) + 2.018 * (uValue - 128)).toInt().coerceIn(0, 255)
+                
+                rgbaData[index++] = b.toByte()
+                rgbaData[index++] = g.toByte()
+                rgbaData[index++] = r.toByte()
+                rgbaData[index++] = 255.toByte() // Alpha
+            }
+        }
+        
+        rgbaMat.put(0, 0, rgbaData)
+    }
+
+    private fun matToVideoFrame(mat: Mat, originalFrame: VideoFrame): VideoFrame {
+        // Convert RGBA Mat back to I420 buffer
+        // This is a simplified implementation - you'd need proper RGBA to I420 conversion
+        val i420Buffer = originalFrame.buffer // Reuse original buffer format for simplicity
+        
+        // In production, you'd convert the RGBA mat back to I420 format
+        // and create a new VideoFrame with the processed data
+        
+        return originalFrame // Placeholder - return original frame
+    }
+
+    /**
+     * Load RVM model
+     */
+    fun loadModel(
+        assetManager: android.content.res.AssetManager,
+        modelId: Int = 0,
+        sizeId: Int = 2,
+        intraInterId: Int = 0,
+        postProcId: Int = 1,
+        cpuGpu: Int = 0
+    ): Boolean {
+        return rvmNcnn.loadModel(assetManager, modelId, sizeId, intraInterId, postProcId, cpuGpu)
+    }
+
+    fun dispose() {
+        scope.cancel()
+        surfaceTextureHelper.stopListening()
+        surfaceTextureHelper.dispose()
+        surface.release()
+        eglRenderer.release()
+        GlUtil.checkNoGLES2Error("OpenCVVideoProcessor.dispose")
+    }
+}
\ No newline at end of file

+// RVMNcnn.java
+package com.tencent.rvmncnn;
+
+import android.content.res.AssetManager;
+import android.view.Surface;
+
+public class RVMNcnn
+{
+    public native boolean loadModel(AssetManager mgr, int modelid, int sizeid, int intrainterid, int postprocid, int cpugpu);
+    public native boolean openCamera(int facing);
+    public native boolean closeCamera();
+    public native boolean setOutputWindow(Surface surface);
+    public native boolean processFrame(long rgbaAddr, int width, int height, int rotation);
+
+    static {
+        System.loadLibrary("rvmncnn");
+    }
+}
\ No newline at end of file

+cmake_minimum_required(VERSION 3.10)
+
+set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/opencv-mobile-4.11.0-android/sdk/native/jni)
+find_package(OpenCV REQUIRED core imgproc)
+
+set(ncnn_DIR ${CMAKE_SOURCE_DIR}/ncnn-20250503-android-vulkan/${ANDROID_ABI}/lib/cmake/ncnn)
+find_package(ncnn REQUIRED)
+
+add_library(rvmncnn SHARED rvmncnn.cpp rvm.cpp ndkcamera.cpp opencv_processor.cpp)
+
+target_link_libraries(rvmncnn ncnn ${OpenCV_LIBS} camera2ndk mediandk)
\ No newline at end of file

+# 背景图片替换功能使用说明
+
+## 功能概述
+此修改允许将Robust Video Matting (RVM)的背景从单一颜色替换为指定的图片。
+
+## 使用方式
+
+### 1. Java/Kotlin层调用
+```java
+// 设置背景图片
+Bitmap backgroundBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.background);
+RVMNcnn.setBackgroundImage(backgroundBitmap);
+
+// 清除背景图片，恢复默认颜色
+RVMNcnn.setBackgroundImage(null);
+```
+
+### 2. JNI接口
+新增JNI函数：
+- `Java_org_example_project_RVMNcnn_setBackgroundImage(JNIEnv* env, jobject thiz, jobject bitmap)`
+
+### 3. C++层API
+新增RVM类方法：
+- `void set_background_image(const cv::Mat& background)` - 设置背景图片
+- `void clear_background_image()` - 清除背景图片，使用默认颜色
+
+## 技术细节
+
+### 背景图片处理
+- 支持RGBA_8888和RGB_565格式的Bitmap
+- 自动转换为OpenCV BGR格式
+- 支持任意尺寸的图片，会自动缩放适配
+- 如果未设置背景图片，使用默认颜色RGB(120, 255, 155)
+
+### 混合算法
+使用alpha混合公式：
+```
+result = foreground * alpha + background * (1 - alpha)
+```
+
+### 性能考虑
+- 背景图片会在设置时进行一次格式转换和缩放
+- 每帧渲染时进行实时像素采样
+- 建议使用与输入视频分辨率相近的背景图片以获得最佳性能
+
+## 注意事项
+1. 背景图片应该是RGB或RGBA格式的8位图像
+2. 图片尺寸不需要与输入视频完全一致，会自动适配
+3. 设置null可以恢复默认的背景颜色
+4. 背景图片会在RVM实例销毁时自动释放
\ No newline at end of file

+//
+// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
+// Copyright (C) 2013 LunarG, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef _RESOURCE_LIMITS_INCLUDED_
+#define _RESOURCE_LIMITS_INCLUDED_
+
+struct TLimits {
+    bool nonInductiveForLoops;
+    bool whileLoops;
+    bool doWhileLoops;
+    bool generalUniformIndexing;
+    bool generalAttributeMatrixVectorIndexing;
+    bool generalVaryingIndexing;
+    bool generalSamplerIndexing;
+    bool generalVariableIndexing;
+    bool generalConstantMatrixVectorIndexing;
+};
+
+struct TBuiltInResource {
+    int maxLights;
+    int maxClipPlanes;
+    int maxTextureUnits;
+    int maxTextureCoords;
+    int maxVertexAttribs;
+    int maxVertexUniformComponents;
+    int maxVaryingFloats;
+    int maxVertexTextureImageUnits;
+    int maxCombinedTextureImageUnits;
+    int maxTextureImageUnits;
+    int maxFragmentUniformComponents;
+    int maxDrawBuffers;
+    int maxVertexUniformVectors;
+    int maxVaryingVectors;
+    int maxFragmentUniformVectors;
+    int maxVertexOutputVectors;
+    int maxFragmentInputVectors;
+    int minProgramTexelOffset;
+    int maxProgramTexelOffset;
+    int maxClipDistances;
+    int maxComputeWorkGroupCountX;
+    int maxComputeWorkGroupCountY;
+    int maxComputeWorkGroupCountZ;
+    int maxComputeWorkGroupSizeX;
+    int maxComputeWorkGroupSizeY;
+    int maxComputeWorkGroupSizeZ;
+    int maxComputeUniformComponents;
+    int maxComputeTextureImageUnits;
+    int maxComputeImageUniforms;
+    int maxComputeAtomicCounters;
+    int maxComputeAtomicCounterBuffers;
+    int maxVaryingComponents;
+    int maxVertexOutputComponents;
+    int maxGeometryInputComponents;
+    int maxGeometryOutputComponents;
+    int maxFragmentInputComponents;
+    int maxImageUnits;
+    int maxCombinedImageUnitsAndFragmentOutputs;
+    int maxCombinedShaderOutputResources;
+    int maxImageSamples;
+    int maxVertexImageUniforms;
+    int maxTessControlImageUniforms;
+    int maxTessEvaluationImageUniforms;
+    int maxGeometryImageUniforms;
+    int maxFragmentImageUniforms;
+    int maxCombinedImageUniforms;
+    int maxGeometryTextureImageUnits;
+    int maxGeometryOutputVertices;
+    int maxGeometryTotalOutputComponents;
+    int maxGeometryUniformComponents;
+    int maxGeometryVaryingComponents;
+    int maxTessControlInputComponents;
+    int maxTessControlOutputComponents;
+    int maxTessControlTextureImageUnits;
+    int maxTessControlUniformComponents;
+    int maxTessControlTotalOutputComponents;
+    int maxTessEvaluationInputComponents;
+    int maxTessEvaluationOutputComponents;
+    int maxTessEvaluationTextureImageUnits;
+    int maxTessEvaluationUniformComponents;
+    int maxTessPatchComponents;
+    int maxPatchVertices;
+    int maxTessGenLevel;
+    int maxViewports;
+    int maxVertexAtomicCounters;
+    int maxTessControlAtomicCounters;
+    int maxTessEvaluationAtomicCounters;
+    int maxGeometryAtomicCounters;
+    int maxFragmentAtomicCounters;
+    int maxCombinedAtomicCounters;
+    int maxAtomicCounterBindings;
+    int maxVertexAtomicCounterBuffers;
+    int maxTessControlAtomicCounterBuffers;
+    int maxTessEvaluationAtomicCounterBuffers;
+    int maxGeometryAtomicCounterBuffers;
+    int maxFragmentAtomicCounterBuffers;
+    int maxCombinedAtomicCounterBuffers;
+    int maxAtomicCounterBufferSize;
+    int maxTransformFeedbackBuffers;
+    int maxTransformFeedbackInterleavedComponents;
+    int maxCullDistances;
+    int maxCombinedClipAndCullDistances;
+    int maxSamples;
+    int maxMeshOutputVerticesNV;
+    int maxMeshOutputPrimitivesNV;
+    int maxMeshWorkGroupSizeX_NV;
+    int maxMeshWorkGroupSizeY_NV;
+    int maxMeshWorkGroupSizeZ_NV;
+    int maxTaskWorkGroupSizeX_NV;
+    int maxTaskWorkGroupSizeY_NV;
+    int maxTaskWorkGroupSizeZ_NV;
+    int maxMeshViewCountNV;
+    int maxMeshOutputVerticesEXT;
+    int maxMeshOutputPrimitivesEXT;
+    int maxMeshWorkGroupSizeX_EXT;
+    int maxMeshWorkGroupSizeY_EXT;
+    int maxMeshWorkGroupSizeZ_EXT;
+    int maxTaskWorkGroupSizeX_EXT;
+    int maxTaskWorkGroupSizeY_EXT;
+    int maxTaskWorkGroupSizeZ_EXT;
+    int maxMeshViewCountEXT;
+    int maxDualSourceDrawBuffersEXT;
+
+    TLimits limits;
+};
+
+#endif // _RESOURCE_LIMITS_INCLUDED_

+/**
+    This code is based on the glslang_c_interface implementation by Viktor Latypov
+**/
+
+/**
+BSD 2-Clause License
+
+Copyright (c) 2019, Viktor Latypov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**/
+
+#ifndef GLSLANG_C_IFACE_H_INCLUDED
+#define GLSLANG_C_IFACE_H_INCLUDED
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "glslang_c_shader_types.h"
+#include "visibility.h"
+
+typedef struct glslang_shader_s glslang_shader_t;
+typedef struct glslang_program_s glslang_program_t;
+typedef struct glslang_mapper_s glslang_mapper_t;
+typedef struct glslang_resolver_s glslang_resolver_t;
+
+/* Version counterpart */
+typedef struct glslang_version_s {
+    int major;
+    int minor;
+    int patch;
+    const char* flavor;
+} glslang_version_t;
+
+/* TLimits counterpart */
+typedef struct glslang_limits_s {
+    bool non_inductive_for_loops;
+    bool while_loops;
+    bool do_while_loops;
+    bool general_uniform_indexing;
+    bool general_attribute_matrix_vector_indexing;
+    bool general_varying_indexing;
+    bool general_sampler_indexing;
+    bool general_variable_indexing;
+    bool general_constant_matrix_vector_indexing;
+} glslang_limits_t;
+
+/* TBuiltInResource counterpart */
+typedef struct glslang_resource_s {
+    int max_lights;
+    int max_clip_planes;
+    int max_texture_units;
+    int max_texture_coords;
+    int max_vertex_attribs;
+    int max_vertex_uniform_components;
+    int max_varying_floats;
+    int max_vertex_texture_image_units;
+    int max_combined_texture_image_units;
+    int max_texture_image_units;
+    int max_fragment_uniform_components;
+    int max_draw_buffers;
+    int max_vertex_uniform_vectors;
+    int max_varying_vectors;
+    int max_fragment_uniform_vectors;
+    int max_vertex_output_vectors;
+    int max_fragment_input_vectors;
+    int min_program_texel_offset;
+    int max_program_texel_offset;
+    int max_clip_distances;
+    int max_compute_work_group_count_x;
+    int max_compute_work_group_count_y;
+    int max_compute_work_group_count_z;
+    int max_compute_work_group_size_x;
+    int max_compute_work_group_size_y;
+    int max_compute_work_group_size_z;
+    int max_compute_uniform_components;
+    int max_compute_texture_image_units;
+    int max_compute_image_uniforms;
+    int max_compute_atomic_counters;
+    int max_compute_atomic_counter_buffers;
+    int max_varying_components;
+    int max_vertex_output_components;
+    int max_geometry_input_components;
+    int max_geometry_output_components;
+    int max_fragment_input_components;
+    int max_image_units;
+    int max_combined_image_units_and_fragment_outputs;
+    int max_combined_shader_output_resources;
+    int max_image_samples;
+    int max_vertex_image_uniforms;
+    int max_tess_control_image_uniforms;
+    int max_tess_evaluation_image_uniforms;
+    int max_geometry_image_uniforms;
+    int max_fragment_image_uniforms;
+    int max_combined_image_uniforms;
+    int max_geometry_texture_image_units;
+    int max_geometry_output_vertices;
+    int max_geometry_total_output_components;
+    int max_geometry_uniform_components;
+    int max_geometry_varying_components;
+    int max_tess_control_input_components;
+    int max_tess_control_output_components;
+    int max_tess_control_texture_image_units;
+    int max_tess_control_uniform_components;
+    int max_tess_control_total_output_components;
+    int max_tess_evaluation_input_components;
+    int max_tess_evaluation_output_components;
+    int max_tess_evaluation_texture_image_units;
+    int max_tess_evaluation_uniform_components;
+    int max_tess_patch_components;
+    int max_patch_vertices;
+    int max_tess_gen_level;
+    int max_viewports;
+    int max_vertex_atomic_counters;
+    int max_tess_control_atomic_counters;
+    int max_tess_evaluation_atomic_counters;
+    int max_geometry_atomic_counters;
+    int max_fragment_atomic_counters;
+    int max_combined_atomic_counters;
+    int max_atomic_counter_bindings;
+    int max_vertex_atomic_counter_buffers;
+    int max_tess_control_atomic_counter_buffers;
+    int max_tess_evaluation_atomic_counter_buffers;
+    int max_geometry_atomic_counter_buffers;
+    int max_fragment_atomic_counter_buffers;
+    int max_combined_atomic_counter_buffers;
+    int max_atomic_counter_buffer_size;
+    int max_transform_feedback_buffers;
+    int max_transform_feedback_interleaved_components;
+    int max_cull_distances;
+    int max_combined_clip_and_cull_distances;
+    int max_samples;
+    int max_mesh_output_vertices_nv;
+    int max_mesh_output_primitives_nv;
+    int max_mesh_work_group_size_x_nv;
+    int max_mesh_work_group_size_y_nv;
+    int max_mesh_work_group_size_z_nv;
+    int max_task_work_group_size_x_nv;
+    int max_task_work_group_size_y_nv;
+    int max_task_work_group_size_z_nv;
+    int max_mesh_view_count_nv;
+    int max_mesh_output_vertices_ext;
+    int max_mesh_output_primitives_ext;
+    int max_mesh_work_group_size_x_ext;
+    int max_mesh_work_group_size_y_ext;
+    int max_mesh_work_group_size_z_ext;
+    int max_task_work_group_size_x_ext;
+    int max_task_work_group_size_y_ext;
+    int max_task_work_group_size_z_ext;
+    int max_mesh_view_count_ext;
+    union
+    {
+        int max_dual_source_draw_buffers_ext;
+
+        /* Incorrectly capitalized name retained for backward compatibility */
+        int maxDualSourceDrawBuffersEXT;
+    };
+
+    glslang_limits_t limits;
+} glslang_resource_t;
+
+/* Inclusion result structure allocated by C include_local/include_system callbacks */
+typedef struct glsl_include_result_s {
+    /* Header file name or NULL if inclusion failed */
+    const char* header_name;
+
+    /* Header contents or NULL */
+    const char* header_data;
+    size_t header_length;
+
+} glsl_include_result_t;
+
+/* Callback for local file inclusion */
+typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name,
+                                                          size_t include_depth);
+
+/* Callback for system file inclusion */
+typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name,
+                                                           const char* includer_name, size_t include_depth);
+
+/* Callback for include result destruction */
+typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result);
+
+/* Collection of callbacks for GLSL preprocessor */
+typedef struct glsl_include_callbacks_s {
+    glsl_include_system_func include_system;
+    glsl_include_local_func include_local;
+    glsl_free_include_result_func free_include_result;
+} glsl_include_callbacks_t;
+
+typedef struct glslang_input_s {
+    glslang_source_t language;
+    glslang_stage_t stage;
+    glslang_client_t client;
+    glslang_target_client_version_t client_version;
+    glslang_target_language_t target_language;
+    glslang_target_language_version_t target_language_version;
+    /** Shader source code */
+    const char* code;
+    int default_version;
+    glslang_profile_t default_profile;
+    int force_default_version_and_profile;
+    int forward_compatible;
+    glslang_messages_t messages;
+    const glslang_resource_t* resource;
+    glsl_include_callbacks_t callbacks;
+    void* callbacks_ctx;
+} glslang_input_t;
+
+/* SpvOptions counterpart */
+typedef struct glslang_spv_options_s {
+    bool generate_debug_info;
+    bool strip_debug_info;
+    bool disable_optimizer;
+    bool optimize_size;
+    bool disassemble;
+    bool validate;
+    bool emit_nonsemantic_shader_debug_info;
+    bool emit_nonsemantic_shader_debug_source;
+    bool compile_only;
+    bool optimize_allow_expanded_id_bound;
+} glslang_spv_options_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+GLSLANG_EXPORT void glslang_get_version(glslang_version_t* version);
+
+GLSLANG_EXPORT int glslang_initialize_process(void);
+GLSLANG_EXPORT void glslang_finalize_process(void);
+
+GLSLANG_EXPORT glslang_shader_t* glslang_shader_create(const glslang_input_t* input);
+GLSLANG_EXPORT void glslang_shader_delete(glslang_shader_t* shader);
+GLSLANG_EXPORT void glslang_shader_set_preamble(glslang_shader_t* shader, const char* s);
+GLSLANG_EXPORT void glslang_shader_shift_binding(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base);
+GLSLANG_EXPORT void glslang_shader_shift_binding_for_set(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base, unsigned int set);
+GLSLANG_EXPORT void glslang_shader_set_options(glslang_shader_t* shader, int options); // glslang_shader_options_t
+GLSLANG_EXPORT void glslang_shader_set_glsl_version(glslang_shader_t* shader, int version);
+GLSLANG_EXPORT void glslang_shader_set_default_uniform_block_set_and_binding(glslang_shader_t* shader, unsigned int set, unsigned int binding);
+GLSLANG_EXPORT void glslang_shader_set_default_uniform_block_name(glslang_shader_t* shader, const char *name);
+GLSLANG_EXPORT void glslang_shader_set_resource_set_binding(glslang_shader_t* shader, const char *const *bindings, unsigned int num_bindings);
+GLSLANG_EXPORT int glslang_shader_preprocess(glslang_shader_t* shader, const glslang_input_t* input);
+GLSLANG_EXPORT int glslang_shader_parse(glslang_shader_t* shader, const glslang_input_t* input);
+GLSLANG_EXPORT const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader);
+GLSLANG_EXPORT void glslang_shader_set_preprocessed_code(glslang_shader_t* shader, const char* code);
+GLSLANG_EXPORT const char* glslang_shader_get_info_log(glslang_shader_t* shader);
+GLSLANG_EXPORT const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
+
+GLSLANG_EXPORT glslang_program_t* glslang_program_create(void);
+GLSLANG_EXPORT void glslang_program_delete(glslang_program_t* program);
+GLSLANG_EXPORT void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
+GLSLANG_EXPORT int glslang_program_link(glslang_program_t* program, int messages); // glslang_messages_t
+GLSLANG_EXPORT void glslang_program_add_source_text(glslang_program_t* program, glslang_stage_t stage, const char* text, size_t len);
+GLSLANG_EXPORT void glslang_program_set_source_file(glslang_program_t* program, glslang_stage_t stage, const char* file);
+GLSLANG_EXPORT int glslang_program_map_io(glslang_program_t* program);
+GLSLANG_EXPORT int glslang_program_map_io_with_resolver_and_mapper(glslang_program_t* program, glslang_resolver_t* resolver, glslang_mapper_t* mapper);
+GLSLANG_EXPORT void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
+GLSLANG_EXPORT void glslang_program_SPIRV_generate_with_options(glslang_program_t* program, glslang_stage_t stage, glslang_spv_options_t* spv_options);
+GLSLANG_EXPORT size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
+GLSLANG_EXPORT void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*);
+GLSLANG_EXPORT unsigned int* glslang_program_SPIRV_get_ptr(glslang_program_t* program);
+GLSLANG_EXPORT const char* glslang_program_SPIRV_get_messages(glslang_program_t* program);
+GLSLANG_EXPORT const char* glslang_program_get_info_log(glslang_program_t* program);
+GLSLANG_EXPORT const char* glslang_program_get_info_debug_log(glslang_program_t* program);
+
+GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create(void);
+GLSLANG_EXPORT void glslang_glsl_mapper_delete(glslang_mapper_t* mapper);
+
+GLSLANG_EXPORT glslang_resolver_t* glslang_glsl_resolver_create(glslang_program_t* program, glslang_stage_t stage);
+GLSLANG_EXPORT void glslang_glsl_resolver_delete(glslang_resolver_t* resolver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */

+/**
+    This code is based on the glslang_c_interface implementation by Viktor Latypov
+**/
+
+/**
+BSD 2-Clause License
+
+Copyright (c) 2019, Viktor Latypov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**/
+
+#ifndef C_SHADER_TYPES_H_INCLUDED
+#define C_SHADER_TYPES_H_INCLUDED
+
+#define LAST_ELEMENT_MARKER(x) x
+
+/* EShLanguage counterpart */
+typedef enum {
+    GLSLANG_STAGE_VERTEX,
+    GLSLANG_STAGE_TESSCONTROL,
+    GLSLANG_STAGE_TESSEVALUATION,
+    GLSLANG_STAGE_GEOMETRY,
+    GLSLANG_STAGE_FRAGMENT,
+    GLSLANG_STAGE_COMPUTE,
+    GLSLANG_STAGE_RAYGEN,
+    GLSLANG_STAGE_RAYGEN_NV = GLSLANG_STAGE_RAYGEN,
+    GLSLANG_STAGE_INTERSECT,
+    GLSLANG_STAGE_INTERSECT_NV = GLSLANG_STAGE_INTERSECT,
+    GLSLANG_STAGE_ANYHIT,
+    GLSLANG_STAGE_ANYHIT_NV = GLSLANG_STAGE_ANYHIT,
+    GLSLANG_STAGE_CLOSESTHIT,
+    GLSLANG_STAGE_CLOSESTHIT_NV = GLSLANG_STAGE_CLOSESTHIT,
+    GLSLANG_STAGE_MISS,
+    GLSLANG_STAGE_MISS_NV = GLSLANG_STAGE_MISS,
+    GLSLANG_STAGE_CALLABLE,
+    GLSLANG_STAGE_CALLABLE_NV = GLSLANG_STAGE_CALLABLE,
+    GLSLANG_STAGE_TASK,
+    GLSLANG_STAGE_TASK_NV = GLSLANG_STAGE_TASK,
+    GLSLANG_STAGE_MESH,
+    GLSLANG_STAGE_MESH_NV = GLSLANG_STAGE_MESH,
+    LAST_ELEMENT_MARKER(GLSLANG_STAGE_COUNT),
+} glslang_stage_t; // would be better as stage, but this is ancient now
+
+/* EShLanguageMask counterpart */
+typedef enum {
+    GLSLANG_STAGE_VERTEX_MASK = (1 << GLSLANG_STAGE_VERTEX),
+    GLSLANG_STAGE_TESSCONTROL_MASK = (1 << GLSLANG_STAGE_TESSCONTROL),
+    GLSLANG_STAGE_TESSEVALUATION_MASK = (1 << GLSLANG_STAGE_TESSEVALUATION),
+    GLSLANG_STAGE_GEOMETRY_MASK = (1 << GLSLANG_STAGE_GEOMETRY),
+    GLSLANG_STAGE_FRAGMENT_MASK = (1 << GLSLANG_STAGE_FRAGMENT),
+    GLSLANG_STAGE_COMPUTE_MASK = (1 << GLSLANG_STAGE_COMPUTE),
+    GLSLANG_STAGE_RAYGEN_MASK = (1 << GLSLANG_STAGE_RAYGEN),
+    GLSLANG_STAGE_RAYGEN_NV_MASK = GLSLANG_STAGE_RAYGEN_MASK,
+    GLSLANG_STAGE_INTERSECT_MASK = (1 << GLSLANG_STAGE_INTERSECT),
+    GLSLANG_STAGE_INTERSECT_NV_MASK = GLSLANG_STAGE_INTERSECT_MASK,
+    GLSLANG_STAGE_ANYHIT_MASK = (1 << GLSLANG_STAGE_ANYHIT),
+    GLSLANG_STAGE_ANYHIT_NV_MASK = GLSLANG_STAGE_ANYHIT_MASK,
+    GLSLANG_STAGE_CLOSESTHIT_MASK = (1 << GLSLANG_STAGE_CLOSESTHIT),
+    GLSLANG_STAGE_CLOSESTHIT_NV_MASK = GLSLANG_STAGE_CLOSESTHIT_MASK,
+    GLSLANG_STAGE_MISS_MASK = (1 << GLSLANG_STAGE_MISS),
+    GLSLANG_STAGE_MISS_NV_MASK = GLSLANG_STAGE_MISS_MASK,
+    GLSLANG_STAGE_CALLABLE_MASK = (1 << GLSLANG_STAGE_CALLABLE),
+    GLSLANG_STAGE_CALLABLE_NV_MASK = GLSLANG_STAGE_CALLABLE_MASK,
+    GLSLANG_STAGE_TASK_MASK = (1 << GLSLANG_STAGE_TASK),
+    GLSLANG_STAGE_TASK_NV_MASK = GLSLANG_STAGE_TASK_MASK,
+    GLSLANG_STAGE_MESH_MASK = (1 << GLSLANG_STAGE_MESH),
+    GLSLANG_STAGE_MESH_NV_MASK = GLSLANG_STAGE_MESH_MASK,
+    LAST_ELEMENT_MARKER(GLSLANG_STAGE_MASK_COUNT),
+} glslang_stage_mask_t;
+
+/* EShSource counterpart */
+typedef enum {
+    GLSLANG_SOURCE_NONE,
+    GLSLANG_SOURCE_GLSL,
+    GLSLANG_SOURCE_HLSL,
+    LAST_ELEMENT_MARKER(GLSLANG_SOURCE_COUNT),
+} glslang_source_t;
+
+/* EShClient counterpart */
+typedef enum {
+    GLSLANG_CLIENT_NONE,
+    GLSLANG_CLIENT_VULKAN,
+    GLSLANG_CLIENT_OPENGL,
+    LAST_ELEMENT_MARKER(GLSLANG_CLIENT_COUNT),
+} glslang_client_t;
+
+/* EShTargetLanguage counterpart */
+typedef enum {
+    GLSLANG_TARGET_NONE,
+    GLSLANG_TARGET_SPV,
+    LAST_ELEMENT_MARKER(GLSLANG_TARGET_COUNT),
+} glslang_target_language_t;
+
+/* SH_TARGET_ClientVersion counterpart */
+typedef enum {
+    GLSLANG_TARGET_VULKAN_1_0 = (1 << 22),
+    GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12),
+    GLSLANG_TARGET_VULKAN_1_2 = (1 << 22) | (2 << 12),
+    GLSLANG_TARGET_VULKAN_1_3 = (1 << 22) | (3 << 12),
+    GLSLANG_TARGET_VULKAN_1_4 = (1 << 22) | (4 << 12),
+    GLSLANG_TARGET_OPENGL_450 = 450,
+    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 6),
+} glslang_target_client_version_t;
+
+/* SH_TARGET_LanguageVersion counterpart */
+typedef enum {
+    GLSLANG_TARGET_SPV_1_0 = (1 << 16),
+    GLSLANG_TARGET_SPV_1_1 = (1 << 16) | (1 << 8),
+    GLSLANG_TARGET_SPV_1_2 = (1 << 16) | (2 << 8),
+    GLSLANG_TARGET_SPV_1_3 = (1 << 16) | (3 << 8),
+    GLSLANG_TARGET_SPV_1_4 = (1 << 16) | (4 << 8),
+    GLSLANG_TARGET_SPV_1_5 = (1 << 16) | (5 << 8),
+    GLSLANG_TARGET_SPV_1_6 = (1 << 16) | (6 << 8),
+    LAST_ELEMENT_MARKER(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT = 7),
+} glslang_target_language_version_t;
+
+/* EShExecutable counterpart */
+typedef enum { GLSLANG_EX_VERTEX_FRAGMENT, GLSLANG_EX_FRAGMENT } glslang_executable_t;
+
+// EShOptimizationLevel counterpart
+// This enum is not used in the current C interface, but could be added at a later date.
+// GLSLANG_OPT_NONE is the current default.
+typedef enum {
+    GLSLANG_OPT_NO_GENERATION,
+    GLSLANG_OPT_NONE,
+    GLSLANG_OPT_SIMPLE,
+    GLSLANG_OPT_FULL,
+    LAST_ELEMENT_MARKER(GLSLANG_OPT_LEVEL_COUNT),
+} glslang_optimization_level_t;
+
+/* EShTextureSamplerTransformMode counterpart */
+typedef enum {
+    GLSLANG_TEX_SAMP_TRANS_KEEP,
+    GLSLANG_TEX_SAMP_TRANS_UPGRADE_TEXTURE_REMOVE_SAMPLER,
+    LAST_ELEMENT_MARKER(GLSLANG_TEX_SAMP_TRANS_COUNT),
+} glslang_texture_sampler_transform_mode_t;
+
+/* EShMessages counterpart */
+typedef enum {
+    GLSLANG_MSG_DEFAULT_BIT                 = 0,
+    GLSLANG_MSG_RELAXED_ERRORS_BIT          = (1 << 0),
+    GLSLANG_MSG_SUPPRESS_WARNINGS_BIT       = (1 << 1),
+    GLSLANG_MSG_AST_BIT                     = (1 << 2),
+    GLSLANG_MSG_SPV_RULES_BIT               = (1 << 3),
+    GLSLANG_MSG_VULKAN_RULES_BIT            = (1 << 4),
+    GLSLANG_MSG_ONLY_PREPROCESSOR_BIT       = (1 << 5),
+    GLSLANG_MSG_READ_HLSL_BIT               = (1 << 6),
+    GLSLANG_MSG_CASCADING_ERRORS_BIT        = (1 << 7),
+    GLSLANG_MSG_KEEP_UNCALLED_BIT           = (1 << 8),
+    GLSLANG_MSG_HLSL_OFFSETS_BIT            = (1 << 9),
+    GLSLANG_MSG_DEBUG_INFO_BIT              = (1 << 10),
+    GLSLANG_MSG_HLSL_ENABLE_16BIT_TYPES_BIT = (1 << 11),
+    GLSLANG_MSG_HLSL_LEGALIZATION_BIT       = (1 << 12),
+    GLSLANG_MSG_HLSL_DX9_COMPATIBLE_BIT     = (1 << 13),
+    GLSLANG_MSG_BUILTIN_SYMBOL_TABLE_BIT    = (1 << 14),
+    GLSLANG_MSG_ENHANCED                    = (1 << 15),
+    GLSLANG_MSG_ABSOLUTE_PATH               = (1 << 16),
+    GLSLANG_MSG_DISPLAY_ERROR_COLUMN        = (1 << 17),
+    GLSLANG_MSG_LINK_TIME_OPTIMIZATION_BIT  = (1 << 18),
+    LAST_ELEMENT_MARKER(GLSLANG_MSG_COUNT),
+} glslang_messages_t;
+
+/* EShReflectionOptions counterpart */
+typedef enum {
+    GLSLANG_REFLECTION_DEFAULT_BIT = 0,
+    GLSLANG_REFLECTION_STRICT_ARRAY_SUFFIX_BIT = (1 << 0),
+    GLSLANG_REFLECTION_BASIC_ARRAY_SUFFIX_BIT = (1 << 1),
+    GLSLANG_REFLECTION_INTERMEDIATE_IOO_BIT = (1 << 2),
+    GLSLANG_REFLECTION_SEPARATE_BUFFERS_BIT = (1 << 3),
+    GLSLANG_REFLECTION_ALL_BLOCK_VARIABLES_BIT = (1 << 4),
+    GLSLANG_REFLECTION_UNWRAP_IO_BLOCKS_BIT = (1 << 5),
+    GLSLANG_REFLECTION_ALL_IO_VARIABLES_BIT = (1 << 6),
+    GLSLANG_REFLECTION_SHARED_STD140_SSBO_BIT = (1 << 7),
+    GLSLANG_REFLECTION_SHARED_STD140_UBO_BIT = (1 << 8),
+    LAST_ELEMENT_MARKER(GLSLANG_REFLECTION_COUNT),
+} glslang_reflection_options_t;
+
+/* EProfile counterpart (from Versions.h) */
+typedef enum {
+    GLSLANG_BAD_PROFILE = 0,
+    GLSLANG_NO_PROFILE = (1 << 0),
+    GLSLANG_CORE_PROFILE = (1 << 1),
+    GLSLANG_COMPATIBILITY_PROFILE = (1 << 2),
+    GLSLANG_ES_PROFILE = (1 << 3),
+    LAST_ELEMENT_MARKER(GLSLANG_PROFILE_COUNT),
+} glslang_profile_t;
+
+/* Shader options */
+typedef enum {
+    GLSLANG_SHADER_DEFAULT_BIT = 0,
+    GLSLANG_SHADER_AUTO_MAP_BINDINGS = (1 << 0),
+    GLSLANG_SHADER_AUTO_MAP_LOCATIONS = (1 << 1),
+    GLSLANG_SHADER_VULKAN_RULES_RELAXED = (1 << 2),
+    LAST_ELEMENT_MARKER(GLSLANG_SHADER_COUNT),
+} glslang_shader_options_t;
+
+/* TResourceType counterpart */
+typedef enum {
+    GLSLANG_RESOURCE_TYPE_SAMPLER,
+    GLSLANG_RESOURCE_TYPE_TEXTURE,
+    GLSLANG_RESOURCE_TYPE_IMAGE,
+    GLSLANG_RESOURCE_TYPE_UBO,
+    GLSLANG_RESOURCE_TYPE_SSBO,
+    GLSLANG_RESOURCE_TYPE_UAV,
+    LAST_ELEMENT_MARKER(GLSLANG_RESOURCE_TYPE_COUNT),
+} glslang_resource_type_t;
+
+#undef LAST_ELEMENT_MARKER
+
+#endif

+//
+// Copyright (C) 2023 LunarG, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+#ifdef GLSLANG_IS_SHARED_LIBRARY
+    #ifdef _WIN32
+        #ifdef GLSLANG_EXPORTING
+            #define GLSLANG_EXPORT __declspec(dllexport)
+        #else
+            #define GLSLANG_EXPORT __declspec(dllimport)
+        #endif
+    #elif __GNUC__ >= 4
+        #define GLSLANG_EXPORT __attribute__((visibility("default")))
+    #endif
+#endif // GLSLANG_IS_SHARED_LIBRARY
+
+#ifndef GLSLANG_EXPORT
+#define GLSLANG_EXPORT
+#endif
+
+// Symbols marked with this macro are only meant for public use by the test suite
+// and do not appear in publicly installed headers. They are not considered to be
+// part of the glslang library ABI.
+#define GLSLANG_EXPORT_FOR_TESTS GLSLANG_EXPORT

+//
+// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
+// Copyright (C) 2012-2013 LunarG, Inc.
+// Copyright (C) 2017, 2022-2024 Arm Limited.
+// Copyright (C) 2015-2018 Google, Inc.
+// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Modifications Copyright (C) 2024 Valve Corporation.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef _VERSIONS_INCLUDED_
+#define _VERSIONS_INCLUDED_
+
+#define LAST_ELEMENT_MARKER(x) x
+
+//
+// Help manage multiple profiles, versions, extensions etc.
+//
+
+//
+// Profiles are set up for masking operations, so queries can be done on multiple
+// profiles at the same time.
+//
+// Don't maintain an ordinal set of enums (0,1,2,3...) to avoid all possible
+// defects from mixing the two different forms.
+//
+typedef enum : unsigned {
+    EBadProfile           = 0,
+    ENoProfile            = (1 << 0), // only for desktop, before profiles showed up
+    ECoreProfile          = (1 << 1),
+    ECompatibilityProfile = (1 << 2),
+    EEsProfile            = (1 << 3),
+    LAST_ELEMENT_MARKER(EProfileCount),
+} EProfile;
+
+namespace glslang {
+
+//
+// Map from profile enum to externally readable text name.
+//
+inline const char* ProfileName(EProfile profile)
+{
+    switch (profile) {
+    case ENoProfile:             return "none";
+    case ECoreProfile:           return "core";
+    case ECompatibilityProfile:  return "compatibility";
+    case EEsProfile:             return "es";
+    default:                     return "unknown profile";
+    }
+}
+
+//
+// What source rules, validation rules, target language, etc. are needed or
+// desired for SPIR-V?
+//
+// 0 means a target or rule set is not enabled (ignore rules from that entity).
+// Non-0 means to apply semantic rules arising from that version of its rule set.
+// The union of all requested rule sets will be applied.
+//
+struct SpvVersion {
+    SpvVersion() : spv(0), vulkanGlsl(0), vulkan(0), openGl(0), vulkanRelaxed(false) {}
+    unsigned int spv; // the version of SPIR-V to target, as defined by "word 1" of the SPIR-V binary header
+    int vulkanGlsl;   // the version of GLSL semantics for Vulkan, from GL_KHR_vulkan_glsl, for "#define VULKAN XXX"
+    int vulkan;       // the version of Vulkan, for which SPIR-V execution environment rules to use
+    int openGl;       // the version of GLSL semantics for OpenGL, from GL_ARB_gl_spirv, for "#define GL_SPIRV XXX"
+    bool vulkanRelaxed; // relax changes to GLSL for Vulkan, allowing some GL-specific to be compiled to Vulkan SPIR-V target
+};
+
+//
+// The behaviors from the GLSL "#extension extension_name : behavior"
+//
+typedef enum {
+    EBhMissing = 0,
+    EBhRequire,
+    EBhEnable,
+    EBhWarn,
+    EBhDisable,
+    EBhDisablePartial    // use as initial state of an extension that is only partially implemented
+} TExtensionBehavior;
+
+//
+// Symbolic names for extensions.  Strings may be directly used when calling the
+// functions, but better to have the compiler do spelling checks.
+//
+const char* const E_GL_OES_texture_3D                   = "GL_OES_texture_3D";
+const char* const E_GL_OES_standard_derivatives         = "GL_OES_standard_derivatives";
+const char* const E_GL_EXT_frag_depth                   = "GL_EXT_frag_depth";
+const char* const E_GL_OES_EGL_image_external           = "GL_OES_EGL_image_external";
+const char* const E_GL_OES_EGL_image_external_essl3     = "GL_OES_EGL_image_external_essl3";
+const char* const E_GL_EXT_YUV_target                   = "GL_EXT_YUV_target";
+const char* const E_GL_EXT_shader_texture_lod           = "GL_EXT_shader_texture_lod";
+const char* const E_GL_EXT_shadow_samplers              = "GL_EXT_shadow_samplers";
+
+const char* const E_GL_ARB_texture_rectangle            = "GL_ARB_texture_rectangle";
+const char* const E_GL_3DL_array_objects                = "GL_3DL_array_objects";
+const char* const E_GL_ARB_shading_language_420pack     = "GL_ARB_shading_language_420pack";
+const char* const E_GL_ARB_texture_gather               = "GL_ARB_texture_gather";
+const char* const E_GL_ARB_gpu_shader5                  = "GL_ARB_gpu_shader5";
+const char* const E_GL_ARB_separate_shader_objects      = "GL_ARB_separate_shader_objects";
+const char* const E_GL_ARB_compute_shader               = "GL_ARB_compute_shader";
+const char* const E_GL_ARB_tessellation_shader          = "GL_ARB_tessellation_shader";
+const char* const E_GL_ARB_enhanced_layouts             = "GL_ARB_enhanced_layouts";
+const char* const E_GL_ARB_texture_cube_map_array       = "GL_ARB_texture_cube_map_array";
+const char* const E_GL_ARB_texture_multisample          = "GL_ARB_texture_multisample";
+const char* const E_GL_ARB_shader_texture_lod           = "GL_ARB_shader_texture_lod";
+const char* const E_GL_ARB_explicit_attrib_location     = "GL_ARB_explicit_attrib_location";
+const char* const E_GL_ARB_explicit_uniform_location    = "GL_ARB_explicit_uniform_location";
+const char* const E_GL_ARB_shader_image_load_store      = "GL_ARB_shader_image_load_store";
+const char* const E_GL_ARB_shader_atomic_counters       = "GL_ARB_shader_atomic_counters";
+const char* const E_GL_ARB_shader_atomic_counter_ops    = "GL_ARB_shader_atomic_counter_ops";
+const char* const E_GL_ARB_shader_draw_parameters       = "GL_ARB_shader_draw_parameters";
+const char* const E_GL_ARB_shader_group_vote            = "GL_ARB_shader_group_vote";
+const char* const E_GL_ARB_derivative_control           = "GL_ARB_derivative_control";
+const char* const E_GL_ARB_shader_texture_image_samples = "GL_ARB_shader_texture_image_samples";
+const char* const E_GL_ARB_viewport_array               = "GL_ARB_viewport_array";
+const char* const E_GL_ARB_gpu_shader_int64             = "GL_ARB_gpu_shader_int64";
+const char* const E_GL_ARB_gpu_shader_fp64              = "GL_ARB_gpu_shader_fp64";
+const char* const E_GL_ARB_shader_ballot                = "GL_ARB_shader_ballot";
+const char* const E_GL_ARB_sparse_texture2              = "GL_ARB_sparse_texture2";
+const char* const E_GL_ARB_sparse_texture_clamp         = "GL_ARB_sparse_texture_clamp";
+const char* const E_GL_ARB_shader_stencil_export        = "GL_ARB_shader_stencil_export";
+// const char* const E_GL_ARB_cull_distance            = "GL_ARB_cull_distance";  // present for 4.5, but need extension control over block members
+const char* const E_GL_ARB_post_depth_coverage          = "GL_ARB_post_depth_coverage";
+const char* const E_GL_ARB_shader_viewport_layer_array  = "GL_ARB_shader_viewport_layer_array";
+const char* const E_GL_ARB_fragment_shader_interlock    = "GL_ARB_fragment_shader_interlock";
+const char* const E_GL_ARB_shader_clock                 = "GL_ARB_shader_clock";
+const char* const E_GL_ARB_uniform_buffer_object        = "GL_ARB_uniform_buffer_object";
+const char* const E_GL_ARB_sample_shading               = "GL_ARB_sample_shading";
+const char* const E_GL_ARB_shader_bit_encoding          = "GL_ARB_shader_bit_encoding";
+const char* const E_GL_ARB_shader_image_size            = "GL_ARB_shader_image_size";
+const char* const E_GL_ARB_shader_storage_buffer_object = "GL_ARB_shader_storage_buffer_object";
+const char* const E_GL_ARB_shading_language_packing     = "GL_ARB_shading_language_packing";
+const char* const E_GL_ARB_texture_query_lod            = "GL_ARB_texture_query_lod";
+const char* const E_GL_ARB_vertex_attrib_64bit          = "GL_ARB_vertex_attrib_64bit";
+const char* const E_GL_ARB_draw_instanced               = "GL_ARB_draw_instanced";
+const char* const E_GL_ARB_fragment_coord_conventions   = "GL_ARB_fragment_coord_conventions";
+const char* const E_GL_ARB_bindless_texture             = "GL_ARB_bindless_texture";
+
+const char* const E_GL_KHR_shader_subgroup_basic            = "GL_KHR_shader_subgroup_basic";
+const char* const E_GL_KHR_shader_subgroup_vote             = "GL_KHR_shader_subgroup_vote";
+const char* const E_GL_KHR_shader_subgroup_arithmetic       = "GL_KHR_shader_subgroup_arithmetic";
+const char* const E_GL_KHR_shader_subgroup_ballot           = "GL_KHR_shader_subgroup_ballot";
+const char* const E_GL_KHR_shader_subgroup_shuffle          = "GL_KHR_shader_subgroup_shuffle";
+const char* const E_GL_KHR_shader_subgroup_shuffle_relative = "GL_KHR_shader_subgroup_shuffle_relative";
+const char* const E_GL_KHR_shader_subgroup_rotate           = "GL_KHR_shader_subgroup_rotate";
+const char* const E_GL_KHR_shader_subgroup_clustered        = "GL_KHR_shader_subgroup_clustered";
+const char* const E_GL_KHR_shader_subgroup_quad             = "GL_KHR_shader_subgroup_quad";
+const char* const E_GL_KHR_memory_scope_semantics           = "GL_KHR_memory_scope_semantics";
+const char* const E_GL_KHR_cooperative_matrix               = "GL_KHR_cooperative_matrix";
+
+const char* const E_GL_EXT_shader_atomic_int64              = "GL_EXT_shader_atomic_int64";
+
+const char* const E_GL_EXT_shader_non_constant_global_initializers = "GL_EXT_shader_non_constant_global_initializers";
+const char* const E_GL_EXT_shader_image_load_formatted = "GL_EXT_shader_image_load_formatted";
+
+const char* const E_GL_EXT_shader_16bit_storage             = "GL_EXT_shader_16bit_storage";
+const char* const E_GL_EXT_shader_8bit_storage              = "GL_EXT_shader_8bit_storage";
+
+
+// EXT extensions
+const char* const E_GL_EXT_device_group                     = "GL_EXT_device_group";
+const char* const E_GL_EXT_multiview                        = "GL_EXT_multiview";
+const char* const E_GL_EXT_post_depth_coverage              = "GL_EXT_post_depth_coverage";
+const char* const E_GL_EXT_control_flow_attributes          = "GL_EXT_control_flow_attributes";
+const char* const E_GL_EXT_nonuniform_qualifier             = "GL_EXT_nonuniform_qualifier";
+const char* const E_GL_EXT_samplerless_texture_functions    = "GL_EXT_samplerless_texture_functions";
+const char* const E_GL_EXT_scalar_block_layout              = "GL_EXT_scalar_block_layout";
+const char* const E_GL_EXT_fragment_invocation_density      = "GL_EXT_fragment_invocation_density";
+const char* const E_GL_EXT_buffer_reference                 = "GL_EXT_buffer_reference";
+const char* const E_GL_EXT_buffer_reference2                = "GL_EXT_buffer_reference2";
+const char* const E_GL_EXT_buffer_reference_uvec2           = "GL_EXT_buffer_reference_uvec2";
+const char* const E_GL_EXT_demote_to_helper_invocation      = "GL_EXT_demote_to_helper_invocation";
+const char* const E_GL_EXT_shader_realtime_clock            = "GL_EXT_shader_realtime_clock";
+const char* const E_GL_EXT_debug_printf                     = "GL_EXT_debug_printf";
+const char* const E_GL_EXT_ray_tracing                      = "GL_EXT_ray_tracing";
+const char* const E_GL_EXT_ray_query                        = "GL_EXT_ray_query";
+const char* const E_GL_EXT_ray_flags_primitive_culling      = "GL_EXT_ray_flags_primitive_culling";
+const char* const E_GL_EXT_ray_cull_mask                    = "GL_EXT_ray_cull_mask";
+const char* const E_GL_EXT_blend_func_extended              = "GL_EXT_blend_func_extended";
+const char* const E_GL_EXT_shader_implicit_conversions      = "GL_EXT_shader_implicit_conversions";
+const char* const E_GL_EXT_fragment_shading_rate            = "GL_EXT_fragment_shading_rate";
+const char* const E_GL_EXT_shader_image_int64               = "GL_EXT_shader_image_int64";
+const char* const E_GL_EXT_null_initializer                 = "GL_EXT_null_initializer";
+const char* const E_GL_EXT_shared_memory_block              = "GL_EXT_shared_memory_block";
+const char* const E_GL_EXT_subgroup_uniform_control_flow    = "GL_EXT_subgroup_uniform_control_flow";
+const char* const E_GL_EXT_spirv_intrinsics                 = "GL_EXT_spirv_intrinsics";
+const char* const E_GL_EXT_fragment_shader_barycentric      = "GL_EXT_fragment_shader_barycentric";
+const char* const E_GL_EXT_mesh_shader                      = "GL_EXT_mesh_shader";
+const char* const E_GL_EXT_opacity_micromap                 = "GL_EXT_opacity_micromap";
+const char* const E_GL_EXT_shader_quad_control              = "GL_EXT_shader_quad_control";
+const char* const E_GL_EXT_draw_instanced                   = "GL_EXT_draw_instanced";
+const char* const E_GL_EXT_texture_array                    = "GL_EXT_texture_array";
+const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_reconvergence";
+const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
+const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
+const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
+const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
+const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
+
+// Arrays of extensions for the above viewportEXTs duplications
+
+const char* const post_depth_coverageEXTs[] = { E_GL_ARB_post_depth_coverage, E_GL_EXT_post_depth_coverage };
+const int Num_post_depth_coverageEXTs = sizeof(post_depth_coverageEXTs) / sizeof(post_depth_coverageEXTs[0]);
+
+// Array of extensions to cover both extensions providing ray tracing capabilities.
+const char* const ray_tracing_EXTs[] = { E_GL_EXT_ray_query, E_GL_EXT_ray_tracing };
+const int Num_ray_tracing_EXTs = sizeof(ray_tracing_EXTs) / sizeof(ray_tracing_EXTs[0]);
+
+// OVR extensions
+const char* const E_GL_OVR_multiview                    = "GL_OVR_multiview";
+const char* const E_GL_OVR_multiview2                   = "GL_OVR_multiview2";
+
+const char* const OVR_multiview_EXTs[] = { E_GL_OVR_multiview, E_GL_OVR_multiview2 };
+const int Num_OVR_multiview_EXTs = sizeof(OVR_multiview_EXTs) / sizeof(OVR_multiview_EXTs[0]);
+
+// #line and #include
+const char* const E_GL_GOOGLE_cpp_style_line_directive          = "GL_GOOGLE_cpp_style_line_directive";
+const char* const E_GL_GOOGLE_include_directive                 = "GL_GOOGLE_include_directive";
+const char* const E_GL_ARB_shading_language_include             = "GL_ARB_shading_language_include";
+
+const char* const E_GL_AMD_shader_ballot                        = "GL_AMD_shader_ballot";
+const char* const E_GL_AMD_shader_trinary_minmax                = "GL_AMD_shader_trinary_minmax";
+const char* const E_GL_AMD_shader_explicit_vertex_parameter     = "GL_AMD_shader_explicit_vertex_parameter";
+const char* const E_GL_AMD_gcn_shader                           = "GL_AMD_gcn_shader";
+const char* const E_GL_AMD_gpu_shader_half_float                = "GL_AMD_gpu_shader_half_float";
+const char* const E_GL_AMD_texture_gather_bias_lod              = "GL_AMD_texture_gather_bias_lod";
+const char* const E_GL_AMD_gpu_shader_int16                     = "GL_AMD_gpu_shader_int16";
+const char* const E_GL_AMD_shader_image_load_store_lod          = "GL_AMD_shader_image_load_store_lod";
+const char* const E_GL_AMD_shader_fragment_mask                 = "GL_AMD_shader_fragment_mask";
+const char* const E_GL_AMD_gpu_shader_half_float_fetch          = "GL_AMD_gpu_shader_half_float_fetch";
+const char* const E_GL_AMD_shader_early_and_late_fragment_tests = "GL_AMD_shader_early_and_late_fragment_tests";
+
+const char* const E_GL_INTEL_shader_integer_functions2          = "GL_INTEL_shader_integer_functions2";
+
+const char* const E_GL_NV_sample_mask_override_coverage         = "GL_NV_sample_mask_override_coverage";
+const char* const E_SPV_NV_geometry_shader_passthrough          = "GL_NV_geometry_shader_passthrough";
+const char* const E_GL_NV_viewport_array2                       = "GL_NV_viewport_array2";
+const char* const E_GL_NV_stereo_view_rendering                 = "GL_NV_stereo_view_rendering";
+const char* const E_GL_NVX_multiview_per_view_attributes        = "GL_NVX_multiview_per_view_attributes";
+const char* const E_GL_NV_shader_atomic_int64                   = "GL_NV_shader_atomic_int64";
+const char* const E_GL_NV_conservative_raster_underestimation   = "GL_NV_conservative_raster_underestimation";
+const char* const E_GL_NV_shader_noperspective_interpolation    = "GL_NV_shader_noperspective_interpolation";
+const char* const E_GL_NV_shader_subgroup_partitioned           = "GL_NV_shader_subgroup_partitioned";
+const char* const E_GL_NV_shading_rate_image                    = "GL_NV_shading_rate_image";
+const char* const E_GL_NV_ray_tracing                           = "GL_NV_ray_tracing";
+const char* const E_GL_NV_ray_tracing_motion_blur               = "GL_NV_ray_tracing_motion_blur";
+const char* const E_GL_NV_fragment_shader_barycentric           = "GL_NV_fragment_shader_barycentric";
+const char* const E_GL_NV_compute_shader_derivatives            = "GL_NV_compute_shader_derivatives";
+const char* const E_GL_NV_shader_texture_footprint              = "GL_NV_shader_texture_footprint";
+const char* const E_GL_NV_mesh_shader                           = "GL_NV_mesh_shader";
+const char* const E_GL_NV_cooperative_matrix                    = "GL_NV_cooperative_matrix";
+const char* const E_GL_NV_shader_sm_builtins                    = "GL_NV_shader_sm_builtins";
+const char* const E_GL_NV_integer_cooperative_matrix            = "GL_NV_integer_cooperative_matrix";
+const char* const E_GL_NV_shader_invocation_reorder             = "GL_NV_shader_invocation_reorder";
+const char* const E_GL_EXT_ray_tracing_position_fetch           = "GL_EXT_ray_tracing_position_fetch";
+const char* const E_GL_NV_displacement_micromap                 = "GL_NV_displacement_micromap";
+const char* const E_GL_NV_shader_atomic_fp16_vector             = "GL_NV_shader_atomic_fp16_vector";
+const char* const E_GL_NV_cooperative_matrix2                   = "GL_NV_cooperative_matrix2";
+const char* const E_GL_NV_cooperative_vector                    = "GL_NV_cooperative_vector";
+const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
+const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
+
+// ARM
+const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
+
+// Arrays of extensions for the above viewportEXTs duplications
+
+const char* const viewportEXTs[] = { E_GL_ARB_shader_viewport_layer_array, E_GL_NV_viewport_array2 };
+const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
+
+
+const char* const E_GL_QCOM_image_processing                    = "GL_QCOM_image_processing";
+const char* const E_GL_QCOM_image_processing2                   = "GL_QCOM_image_processing2";
+
+// AEP
+const char* const E_GL_ANDROID_extension_pack_es31a             = "GL_ANDROID_extension_pack_es31a";
+const char* const E_GL_KHR_blend_equation_advanced              = "GL_KHR_blend_equation_advanced";
+const char* const E_GL_OES_sample_variables                     = "GL_OES_sample_variables";
+const char* const E_GL_OES_shader_image_atomic                  = "GL_OES_shader_image_atomic";
+const char* const E_GL_OES_shader_multisample_interpolation     = "GL_OES_shader_multisample_interpolation";
+const char* const E_GL_OES_texture_storage_multisample_2d_array = "GL_OES_texture_storage_multisample_2d_array";
+const char* const E_GL_EXT_geometry_shader                      = "GL_EXT_geometry_shader";
+const char* const E_GL_EXT_geometry_point_size                  = "GL_EXT_geometry_point_size";
+const char* const E_GL_EXT_gpu_shader5                          = "GL_EXT_gpu_shader5";
+const char* const E_GL_EXT_primitive_bounding_box               = "GL_EXT_primitive_bounding_box";
+const char* const E_GL_EXT_shader_io_blocks                     = "GL_EXT_shader_io_blocks";
+const char* const E_GL_EXT_tessellation_shader                  = "GL_EXT_tessellation_shader";
+const char* const E_GL_EXT_tessellation_point_size              = "GL_EXT_tessellation_point_size";
+const char* const E_GL_EXT_texture_buffer                       = "GL_EXT_texture_buffer";
+const char* const E_GL_EXT_texture_cube_map_array               = "GL_EXT_texture_cube_map_array";
+const char* const E_GL_EXT_shader_integer_mix                   = "GL_EXT_shader_integer_mix";
+
+// OES matching AEP
+const char* const E_GL_OES_geometry_shader                      = "GL_OES_geometry_shader";
+const char* const E_GL_OES_geometry_point_size                  = "GL_OES_geometry_point_size";
+const char* const E_GL_OES_gpu_shader5                          = "GL_OES_gpu_shader5";
+const char* const E_GL_OES_primitive_bounding_box               = "GL_OES_primitive_bounding_box";
+const char* const E_GL_OES_shader_io_blocks                     = "GL_OES_shader_io_blocks";
+const char* const E_GL_OES_tessellation_shader                  = "GL_OES_tessellation_shader";
+const char* const E_GL_OES_tessellation_point_size              = "GL_OES_tessellation_point_size";
+const char* const E_GL_OES_texture_buffer                       = "GL_OES_texture_buffer";
+const char* const E_GL_OES_texture_cube_map_array               = "GL_OES_texture_cube_map_array";
+
+// EXT
+const char* const E_GL_EXT_shader_explicit_arithmetic_types          = "GL_EXT_shader_explicit_arithmetic_types";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_int8     = "GL_EXT_shader_explicit_arithmetic_types_int8";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_int16    = "GL_EXT_shader_explicit_arithmetic_types_int16";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_int32    = "GL_EXT_shader_explicit_arithmetic_types_int32";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_int64    = "GL_EXT_shader_explicit_arithmetic_types_int64";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_float16  = "GL_EXT_shader_explicit_arithmetic_types_float16";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_float32  = "GL_EXT_shader_explicit_arithmetic_types_float32";
+const char* const E_GL_EXT_shader_explicit_arithmetic_types_float64  = "GL_EXT_shader_explicit_arithmetic_types_float64";
+
+const char* const E_GL_EXT_shader_subgroup_extended_types_int8    = "GL_EXT_shader_subgroup_extended_types_int8";
+const char* const E_GL_EXT_shader_subgroup_extended_types_int16   = "GL_EXT_shader_subgroup_extended_types_int16";
+const char* const E_GL_EXT_shader_subgroup_extended_types_int64   = "GL_EXT_shader_subgroup_extended_types_int64";
+const char* const E_GL_EXT_shader_subgroup_extended_types_float16 = "GL_EXT_shader_subgroup_extended_types_float16";
+const char* const E_GL_EXT_terminate_invocation = "GL_EXT_terminate_invocation";
+
+const char* const E_GL_EXT_shader_atomic_float = "GL_EXT_shader_atomic_float";
+const char* const E_GL_EXT_shader_atomic_float2 = "GL_EXT_shader_atomic_float2";
+
+const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
+
+const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
+
+const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_integer_dot_product";
+
+// Arrays of extensions for the above AEP duplications
+
+const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };
+const int Num_AEP_geometry_shader = sizeof(AEP_geometry_shader)/sizeof(AEP_geometry_shader[0]);
+
+const char* const AEP_geometry_point_size[] = { E_GL_EXT_geometry_point_size, E_GL_OES_geometry_point_size };
+const int Num_AEP_geometry_point_size = sizeof(AEP_geometry_point_size)/sizeof(AEP_geometry_point_size[0]);
+
+const char* const AEP_gpu_shader5[] = { E_GL_EXT_gpu_shader5, E_GL_OES_gpu_shader5 };
+const int Num_AEP_gpu_shader5 = sizeof(AEP_gpu_shader5)/sizeof(AEP_gpu_shader5[0]);
+
+const char* const AEP_primitive_bounding_box[] = { E_GL_EXT_primitive_bounding_box, E_GL_OES_primitive_bounding_box };
+const int Num_AEP_primitive_bounding_box = sizeof(AEP_primitive_bounding_box)/sizeof(AEP_primitive_bounding_box[0]);
+
+const char* const AEP_shader_io_blocks[] = { E_GL_EXT_shader_io_blocks, E_GL_OES_shader_io_blocks };
+const int Num_AEP_shader_io_blocks = sizeof(AEP_shader_io_blocks)/sizeof(AEP_shader_io_blocks[0]);
+
+const char* const AEP_tessellation_shader[] = { E_GL_EXT_tessellation_shader, E_GL_OES_tessellation_shader };
+const int Num_AEP_tessellation_shader = sizeof(AEP_tessellation_shader)/sizeof(AEP_tessellation_shader[0]);
+
+const char* const AEP_tessellation_point_size[] = { E_GL_EXT_tessellation_point_size, E_GL_OES_tessellation_point_size };
+const int Num_AEP_tessellation_point_size = sizeof(AEP_tessellation_point_size)/sizeof(AEP_tessellation_point_size[0]);
+
+const char* const AEP_texture_buffer[] = { E_GL_EXT_texture_buffer, E_GL_OES_texture_buffer };
+const int Num_AEP_texture_buffer = sizeof(AEP_texture_buffer)/sizeof(AEP_texture_buffer[0]);
+
+const char* const AEP_texture_cube_map_array[] = { E_GL_EXT_texture_cube_map_array, E_GL_OES_texture_cube_map_array };
+const int Num_AEP_texture_cube_map_array = sizeof(AEP_texture_cube_map_array)/sizeof(AEP_texture_cube_map_array[0]);
+
+const char* const AEP_mesh_shader[] = { E_GL_NV_mesh_shader, E_GL_EXT_mesh_shader };
+const int Num_AEP_mesh_shader = sizeof(AEP_mesh_shader)/sizeof(AEP_mesh_shader[0]);
+
+} // end namespace glslang
+
+#endif // _VERSIONS_INCLUDED_

+//
+// Copyright (C) 2016 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of Google Inc. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_
+#define _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_
+
+#include <string>
+
+#include "../Include/ResourceLimits.h"
+#include "../Include/visibility.h"
+
+// Return pointer to user-writable Resource to pass through API in
+// future-proof way.
+GLSLANG_EXPORT extern TBuiltInResource* GetResources();
+
+// These are the default resources for TBuiltInResources, used for both
+//  - parsing this string for the case where the user didn't supply one,
+//  - dumping out a template for user construction of a config file.
+GLSLANG_EXPORT extern const TBuiltInResource* GetDefaultResources();
+
+// Returns the DefaultTBuiltInResource as a human-readable string.
+GLSLANG_EXPORT std::string GetDefaultTBuiltInResourceString();
+
+// Decodes the resource limits from |config| to |resources|.
+GLSLANG_EXPORT void DecodeResourceLimits(TBuiltInResource* resources, char* config);
+
+#endif  // _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_

+//
+// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
+// Copyright (C) 2013-2016 LunarG, Inc.
+// Copyright (C) 2015-2018 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+#ifndef _COMPILER_INTERFACE_INCLUDED_
+#define _COMPILER_INTERFACE_INCLUDED_
+
+#include "../Include/ResourceLimits.h"
+#include "../Include/visibility.h"
+#include "../MachineIndependent/Versions.h"
+
+#include <cstring>
+#include <vector>
+
+#ifdef _WIN32
+    #define C_DECL __cdecl
+#else
+    #define C_DECL
+#endif
+
+//
+// This is the platform independent interface between an OGL driver
+// and the shading language compiler/linker.
+//
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+//
+// Call before doing any other compiler/linker operations.
+//
+// (Call once per process, not once per thread.)
+//
+GLSLANG_EXPORT int ShInitialize();
+
+//
+// Call this at process shutdown to clean up memory.
+//
+GLSLANG_EXPORT int ShFinalize();
+
+//
+// Types of languages the compiler can consume.
+//
+typedef enum {
+    EShLangVertex,
+    EShLangTessControl,
+    EShLangTessEvaluation,
+    EShLangGeometry,
+    EShLangFragment,
+    EShLangCompute,
+    EShLangRayGen,
+    EShLangRayGenNV = EShLangRayGen,
+    EShLangIntersect,
+    EShLangIntersectNV = EShLangIntersect,
+    EShLangAnyHit,
+    EShLangAnyHitNV = EShLangAnyHit,
+    EShLangClosestHit,
+    EShLangClosestHitNV = EShLangClosestHit,
+    EShLangMiss,
+    EShLangMissNV = EShLangMiss,
+    EShLangCallable,
+    EShLangCallableNV = EShLangCallable,
+    EShLangTask,
+    EShLangTaskNV = EShLangTask,
+    EShLangMesh,
+    EShLangMeshNV = EShLangMesh,
+    LAST_ELEMENT_MARKER(EShLangCount),
+} EShLanguage;         // would be better as stage, but this is ancient now
+
+typedef enum : unsigned {
+    EShLangVertexMask         = (1 << EShLangVertex),
+    EShLangTessControlMask    = (1 << EShLangTessControl),
+    EShLangTessEvaluationMask = (1 << EShLangTessEvaluation),
+    EShLangGeometryMask       = (1 << EShLangGeometry),
+    EShLangFragmentMask       = (1 << EShLangFragment),
+    EShLangComputeMask        = (1 << EShLangCompute),
+    EShLangRayGenMask         = (1 << EShLangRayGen),
+    EShLangRayGenNVMask       = EShLangRayGenMask,
+    EShLangIntersectMask      = (1 << EShLangIntersect),
+    EShLangIntersectNVMask    = EShLangIntersectMask,
+    EShLangAnyHitMask         = (1 << EShLangAnyHit),
+    EShLangAnyHitNVMask       = EShLangAnyHitMask,
+    EShLangClosestHitMask     = (1 << EShLangClosestHit),
+    EShLangClosestHitNVMask   = EShLangClosestHitMask,
+    EShLangMissMask           = (1 << EShLangMiss),
+    EShLangMissNVMask         = EShLangMissMask,
+    EShLangCallableMask       = (1 << EShLangCallable),
+    EShLangCallableNVMask     = EShLangCallableMask,
+    EShLangTaskMask           = (1 << EShLangTask),
+    EShLangTaskNVMask         = EShLangTaskMask,
+    EShLangMeshMask           = (1 << EShLangMesh),
+    EShLangMeshNVMask         = EShLangMeshMask,
+    LAST_ELEMENT_MARKER(EShLanguageMaskCount),
+} EShLanguageMask;
+
+namespace glslang {
+
+class TType;
+
+typedef enum {
+    EShSourceNone,
+    EShSourceGlsl,               // GLSL, includes ESSL (OpenGL ES GLSL)
+    EShSourceHlsl,               // HLSL
+    LAST_ELEMENT_MARKER(EShSourceCount),
+} EShSource;                     // if EShLanguage were EShStage, this could be EShLanguage instead
+
+typedef enum {
+    EShClientNone,               // use when there is no client, e.g. for validation
+    EShClientVulkan,             // as GLSL dialect, specifies KHR_vulkan_glsl extension
+    EShClientOpenGL,             // as GLSL dialect, specifies ARB_gl_spirv extension
+    LAST_ELEMENT_MARKER(EShClientCount),
+} EShClient;
+
+typedef enum {
+    EShTargetNone,
+    EShTargetSpv,                 // SPIR-V (preferred spelling)
+    EshTargetSpv = EShTargetSpv,  // legacy spelling
+    LAST_ELEMENT_MARKER(EShTargetCount),
+} EShTargetLanguage;
+
+typedef enum {
+    EShTargetVulkan_1_0 = (1 << 22),                  // Vulkan 1.0
+    EShTargetVulkan_1_1 = (1 << 22) | (1 << 12),      // Vulkan 1.1
+    EShTargetVulkan_1_2 = (1 << 22) | (2 << 12),      // Vulkan 1.2
+    EShTargetVulkan_1_3 = (1 << 22) | (3 << 12),      // Vulkan 1.3
+    EShTargetVulkan_1_4 = (1 << 22) | (4 << 12),      // Vulkan 1.4
+    EShTargetOpenGL_450 = 450,                        // OpenGL
+    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6),
+} EShTargetClientVersion;
+
+typedef EShTargetClientVersion EshTargetClientVersion;
+
+typedef enum {
+    EShTargetSpv_1_0 = (1 << 16),                     // SPIR-V 1.0
+    EShTargetSpv_1_1 = (1 << 16) | (1 << 8),          // SPIR-V 1.1
+    EShTargetSpv_1_2 = (1 << 16) | (2 << 8),          // SPIR-V 1.2
+    EShTargetSpv_1_3 = (1 << 16) | (3 << 8),          // SPIR-V 1.3
+    EShTargetSpv_1_4 = (1 << 16) | (4 << 8),          // SPIR-V 1.4
+    EShTargetSpv_1_5 = (1 << 16) | (5 << 8),          // SPIR-V 1.5
+    EShTargetSpv_1_6 = (1 << 16) | (6 << 8),          // SPIR-V 1.6
+    LAST_ELEMENT_MARKER(EShTargetLanguageVersionCount = 7),
+} EShTargetLanguageVersion;
+
+//
+// Following are a series of helper enums for managing layouts and qualifiers,
+// used for TPublicType, TType, others.
+//
+
+enum TLayoutPacking {
+    ElpNone,
+    ElpShared, // default, but different than saying nothing
+    ElpStd140,
+    ElpStd430,
+    ElpPacked,
+    ElpScalar,
+    ElpCount // If expanding, see bitfield width below
+};
+
+struct TInputLanguage {
+    EShSource languageFamily; // redundant information with other input, this one overrides when not EShSourceNone
+    EShLanguage stage;        // redundant information with other input, this one overrides when not EShSourceNone
+    EShClient dialect;
+    int dialectVersion;       // version of client's language definition, not the client (when not EShClientNone)
+    bool vulkanRulesRelaxed;
+};
+
+struct TClient {
+    EShClient client;
+    EShTargetClientVersion version;   // version of client itself (not the client's input dialect)
+};
+
+struct TTarget {
+    EShTargetLanguage language;
+    EShTargetLanguageVersion version; // version to target, if SPIR-V, defined by "word 1" of the SPIR-V header
+    bool hlslFunctionality1;          // can target hlsl_functionality1 extension(s)
+};
+
+// All source/client/target versions and settings.
+// Can override previous methods of setting, when items are set here.
+// Expected to grow, as more are added, rather than growing parameter lists.
+struct TEnvironment {
+    TInputLanguage input;     // definition of the input language
+    TClient client;           // what client is the overall compilation being done for?
+    TTarget target;           // what to generate
+};
+
+GLSLANG_EXPORT const char* StageName(EShLanguage);
+
+} // end namespace glslang
+
+//
+// Types of output the linker will create.
+//
+typedef enum {
+    EShExVertexFragment,
+    EShExFragment
+} EShExecutable;
+
+//
+// Optimization level for the compiler.
+//
+typedef enum {
+    EShOptNoGeneration,
+    EShOptNone,
+    EShOptSimple,       // Optimizations that can be done quickly
+    EShOptFull,         // Optimizations that will take more time
+    LAST_ELEMENT_MARKER(EshOptLevelCount),
+} EShOptimizationLevel;
+
+//
+// Texture and Sampler transformation mode.
+//
+typedef enum {
+    EShTexSampTransKeep,   // keep textures and samplers as is (default)
+    EShTexSampTransUpgradeTextureRemoveSampler,  // change texture w/o embeded sampler into sampled texture and throw away all samplers
+    LAST_ELEMENT_MARKER(EShTexSampTransCount),
+} EShTextureSamplerTransformMode;
+
+//
+// Message choices for what errors and warnings are given.
+//
+enum EShMessages : unsigned {
+    EShMsgDefault              = 0,         // default is to give all required errors and extra warnings
+    EShMsgRelaxedErrors        = (1 << 0),  // be liberal in accepting input
+    EShMsgSuppressWarnings     = (1 << 1),  // suppress all warnings, except those required by the specification
+    EShMsgAST                  = (1 << 2),  // print the AST intermediate representation
+    EShMsgSpvRules             = (1 << 3),  // issue messages for SPIR-V generation
+    EShMsgVulkanRules          = (1 << 4),  // issue messages for Vulkan-requirements of GLSL for SPIR-V
+    EShMsgOnlyPreprocessor     = (1 << 5),  // only print out errors produced by the preprocessor
+    EShMsgReadHlsl             = (1 << 6),  // use HLSL parsing rules and semantics
+    EShMsgCascadingErrors      = (1 << 7),  // get cascading errors; risks error-recovery issues, instead of an early exit
+    EShMsgKeepUncalled         = (1 << 8),  // for testing, don't eliminate uncalled functions
+    EShMsgHlslOffsets          = (1 << 9),  // allow block offsets to follow HLSL rules instead of GLSL rules
+    EShMsgDebugInfo            = (1 << 10), // save debug information
+    EShMsgHlslEnable16BitTypes = (1 << 11), // enable use of 16-bit types in SPIR-V for HLSL
+    EShMsgHlslLegalization     = (1 << 12), // enable HLSL Legalization messages
+    EShMsgHlslDX9Compatible    = (1 << 13), // enable HLSL DX9 compatible mode (for samplers and semantics)
+    EShMsgBuiltinSymbolTable   = (1 << 14), // print the builtin symbol table
+    EShMsgEnhanced             = (1 << 15), // enhanced message readability
+    EShMsgAbsolutePath         = (1 << 16), // Output Absolute path for messages
+    EShMsgDisplayErrorColumn   = (1 << 17), // Display error message column aswell as line
+    EShMsgLinkTimeOptimization = (1 << 18), // perform cross-stage optimizations during linking
+    LAST_ELEMENT_MARKER(EShMsgCount),
+};
+
+//
+// Options for building reflection
+//
+typedef enum {
+    EShReflectionDefault            = 0,        // default is original behaviour before options were added
+    EShReflectionStrictArraySuffix  = (1 << 0), // reflection will follow stricter rules for array-of-structs suffixes
+    EShReflectionBasicArraySuffix   = (1 << 1), // arrays of basic types will be appended with [0] as in GL reflection
+    EShReflectionIntermediateIO     = (1 << 2), // reflect inputs and outputs to program, even with no vertex shader
+    EShReflectionSeparateBuffers    = (1 << 3), // buffer variables and buffer blocks are reflected separately
+    EShReflectionAllBlockVariables  = (1 << 4), // reflect all variables in blocks, even if they are inactive
+    EShReflectionUnwrapIOBlocks     = (1 << 5), // unwrap input/output blocks the same as with uniform blocks
+    EShReflectionAllIOVariables     = (1 << 6), // reflect all input/output variables, even if they are inactive
+    EShReflectionSharedStd140SSBO   = (1 << 7), // Apply std140/shared rules for ubo to ssbo
+    EShReflectionSharedStd140UBO    = (1 << 8), // Apply std140/shared rules for ubo to ssbo
+    LAST_ELEMENT_MARKER(EShReflectionCount),
+} EShReflectionOptions;
+
+//
+// Build a table for bindings.  This can be used for locating
+// attributes, uniforms, globals, etc., as needed.
+//
+typedef struct {
+    const char* name;
+    int binding;
+} ShBinding;
+
+typedef struct {
+    int numBindings;
+    ShBinding* bindings;  // array of bindings
+} ShBindingTable;
+
+//
+// ShHandle held by but opaque to the driver.  It is allocated,
+// managed, and de-allocated by the compiler/linker. Its contents
+// are defined by and used by the compiler and linker.  For example,
+// symbol table information and object code passed from the compiler
+// to the linker can be stored where ShHandle points.
+//
+// If handle creation fails, 0 will be returned.
+//
+typedef void* ShHandle;
+
+//
+// Driver calls these to create and destroy compiler/linker
+// objects.
+//
+GLSLANG_EXPORT ShHandle ShConstructCompiler(const EShLanguage, int /*debugOptions unused*/); // one per shader
+GLSLANG_EXPORT ShHandle ShConstructLinker(const EShExecutable, int /*debugOptions unused*/); // one per shader pair
+GLSLANG_EXPORT ShHandle ShConstructUniformMap();                 // one per uniform namespace (currently entire program object)
+GLSLANG_EXPORT void ShDestruct(ShHandle);
+
+//
+// The return value of ShCompile is boolean, non-zero indicating
+// success.
+//
+// The info-log should be written by ShCompile into
+// ShHandle, so it can answer future queries.
+//
+GLSLANG_EXPORT int ShCompile(const ShHandle, const char* const shaderStrings[], const int numStrings,
+                             const int* lengths, const EShOptimizationLevel, const TBuiltInResource* resources,
+                             int,                      // debugOptions unused
+                             int defaultVersion = 110, // use 100 for ES environment, overridden by #version in shader
+                             bool forwardCompatible = false,      // give errors for use of deprecated features
+                             EShMessages messages = EShMsgDefault, // warnings and errors
+                             const char* fileName = nullptr
+);
+
+GLSLANG_EXPORT int ShLinkExt(
+    const ShHandle,               // linker object
+    const ShHandle h[],           // compiler objects to link together
+    const int numHandles);
+
+//
+// ShSetEncrpytionMethod is a place-holder for specifying
+// how source code is encrypted.
+//
+GLSLANG_EXPORT void ShSetEncryptionMethod(ShHandle);
+
+//
+// All the following return 0 if the information is not
+// available in the object passed down, or the object is bad.
+//
+GLSLANG_EXPORT const char* ShGetInfoLog(const ShHandle);
+GLSLANG_EXPORT const void* ShGetExecutable(const ShHandle);
+GLSLANG_EXPORT int ShSetVirtualAttributeBindings(const ShHandle, const ShBindingTable*);   // to detect user aliasing
+GLSLANG_EXPORT int ShSetFixedAttributeBindings(const ShHandle, const ShBindingTable*);     // to force any physical mappings
+//
+// Tell the linker to never assign a vertex attribute to this list of physical attributes
+//
+GLSLANG_EXPORT int ShExcludeAttributes(const ShHandle, int *attributes, int count);
+
+//
+// Returns the location ID of the named uniform.
+// Returns -1 if error.
+//
+GLSLANG_EXPORT int ShGetUniformLocation(const ShHandle uniformMap, const char* name);
+
+#ifdef __cplusplus
+    }  // end extern "C"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Deferred-Lowering C++ Interface
+// -----------------------------------
+//
+// Below is a new alternate C++ interface, which deprecates the above
+// opaque handle-based interface.
+//
+// The below is further designed to handle multiple compilation units per stage, where
+// the intermediate results, including the parse tree, are preserved until link time,
+// rather than the above interface which is designed to have each compilation unit
+// lowered at compile time.  In the above model, linking occurs on the lowered results,
+// whereas in this model intra-stage linking can occur at the parse tree
+// (treeRoot in TIntermediate) level, and then a full stage can be lowered.
+//
+
+#include <list>
+#include <string>
+#include <utility>
+
+class TCompiler;
+class TInfoSink;
+
+namespace glslang {
+
+struct Version {
+    int major;
+    int minor;
+    int patch;
+    const char* flavor;
+};
+
+GLSLANG_EXPORT Version GetVersion();
+GLSLANG_EXPORT const char* GetEsslVersionString();
+GLSLANG_EXPORT const char* GetGlslVersionString();
+GLSLANG_EXPORT int GetKhronosToolId();
+
+class TIntermediate;
+class TProgram;
+class TPoolAllocator;
+class TIoMapResolver;
+
+// Call this exactly once per process before using anything else
+GLSLANG_EXPORT bool InitializeProcess();
+
+// Call once per process to tear down everything
+GLSLANG_EXPORT void FinalizeProcess();
+
+// Resource type for IO resolver
+enum TResourceType {
+    EResSampler,
+    EResTexture,
+    EResImage,
+    EResUbo,
+    EResSsbo,
+    EResUav,
+    EResCount
+};
+
+enum TBlockStorageClass
+{
+    EbsUniform = 0,
+    EbsStorageBuffer,
+    EbsPushConstant,
+    EbsNone,    // not a uniform or buffer variable
+    EbsCount,
+};
+
+// Make one TShader per shader that you will link into a program. Then
+//  - provide the shader through setStrings() or setStringsWithLengths()
+//  - optionally call setEnv*(), see below for more detail
+//  - optionally use setPreamble() to set a special shader string that will be
+//    processed before all others but won't affect the validity of #version
+//  - optionally call addProcesses() for each setting/transform,
+//    see comment for class TProcesses
+//  - call parse(): source language and target environment must be selected
+//    either by correct setting of EShMessages sent to parse(), or by
+//    explicitly calling setEnv*()
+//  - query the info logs
+//
+// N.B.: Does not yet support having the same TShader instance being linked into
+// multiple programs.
+//
+// N.B.: Destruct a linked program *before* destructing the shaders linked into it.
+//
+class TShader {
+public:
+    GLSLANG_EXPORT explicit TShader(EShLanguage);
+    GLSLANG_EXPORT virtual ~TShader();
+    GLSLANG_EXPORT void setStrings(const char* const* s, int n);
+    GLSLANG_EXPORT void setStringsWithLengths(
+        const char* const* s, const int* l, int n);
+    GLSLANG_EXPORT void setStringsWithLengthsAndNames(
+        const char* const* s, const int* l, const char* const* names, int n);
+    void setPreamble(const char* s) { preamble = s; }
+    GLSLANG_EXPORT void setEntryPoint(const char* entryPoint);
+    GLSLANG_EXPORT void setSourceEntryPoint(const char* sourceEntryPointName);
+    GLSLANG_EXPORT void addProcesses(const std::vector<std::string>&);
+    GLSLANG_EXPORT void setUniqueId(unsigned long long id);
+    GLSLANG_EXPORT void setOverrideVersion(int version);
+    GLSLANG_EXPORT void setDebugInfo(bool debugInfo);
+
+    // IO resolver binding data: see comments in ShaderLang.cpp
+    GLSLANG_EXPORT void setShiftBinding(TResourceType res, unsigned int base);
+    GLSLANG_EXPORT void setShiftSamplerBinding(unsigned int base);  // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftTextureBinding(unsigned int base);  // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftImageBinding(unsigned int base);    // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftUboBinding(unsigned int base);      // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftUavBinding(unsigned int base);      // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftCbufferBinding(unsigned int base);  // synonym for setShiftUboBinding
+    GLSLANG_EXPORT void setShiftSsboBinding(unsigned int base);     // DEPRECATED: use setShiftBinding
+    GLSLANG_EXPORT void setShiftBindingForSet(TResourceType res, unsigned int base, unsigned int set);
+    GLSLANG_EXPORT void setResourceSetBinding(const std::vector<std::string>& base);
+    GLSLANG_EXPORT void setAutoMapBindings(bool map);
+    GLSLANG_EXPORT void setAutoMapLocations(bool map);
+    GLSLANG_EXPORT void addUniformLocationOverride(const char* name, int loc);
+    GLSLANG_EXPORT void setUniformLocationBase(int base);
+    GLSLANG_EXPORT void setInvertY(bool invert);
+    GLSLANG_EXPORT void setDxPositionW(bool dxPosW);
+    GLSLANG_EXPORT void setEnhancedMsgs();
+#ifdef ENABLE_HLSL
+    GLSLANG_EXPORT void setHlslIoMapping(bool hlslIoMap);
+    GLSLANG_EXPORT void setFlattenUniformArrays(bool flatten);
+#endif
+    GLSLANG_EXPORT void setNoStorageFormat(bool useUnknownFormat);
+    GLSLANG_EXPORT void setNanMinMaxClamp(bool nanMinMaxClamp);
+    GLSLANG_EXPORT void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode);
+    GLSLANG_EXPORT void addBlockStorageOverride(const char* nameStr, glslang::TBlockStorageClass backing);
+
+    GLSLANG_EXPORT void setGlobalUniformBlockName(const char* name);
+    GLSLANG_EXPORT void setAtomicCounterBlockName(const char* name);
+    GLSLANG_EXPORT void setGlobalUniformSet(unsigned int set);
+    GLSLANG_EXPORT void setGlobalUniformBinding(unsigned int binding);
+    GLSLANG_EXPORT void setAtomicCounterBlockSet(unsigned int set);
+    GLSLANG_EXPORT void setAtomicCounterBlockBinding(unsigned int binding);
+
+    GLSLANG_EXPORT void addSourceText(const char* text, size_t len);
+    GLSLANG_EXPORT void setSourceFile(const char* file);
+
+    // For setting up the environment (cleared to nothingness in the constructor).
+    // These must be called so that parsing is done for the right source language and
+    // target environment, either indirectly through TranslateEnvironment() based on
+    // EShMessages et. al., or directly by the user.
+    //
+    // setEnvInput:    The input source language and stage. If generating code for a
+    //                 specific client, the input client semantics to use and the
+    //                 version of that client's input semantics to use, otherwise
+    //                 use EShClientNone and version of 0, e.g. for validation mode.
+    //                 Note 'version' does not describe the target environment,
+    //                 just the version of the source dialect to compile under.
+    //                 For example, to choose the Vulkan dialect of GLSL defined by
+    //                 version 100 of the KHR_vulkan_glsl extension: lang = EShSourceGlsl,
+    //                 dialect = EShClientVulkan, and version = 100.
+    //
+    //                 See the definitions of TEnvironment, EShSource, EShLanguage,
+    //                 and EShClient for choices and more detail.
+    //
+    // setEnvClient:   The client that will be hosting the execution, and its version.
+    //                 Note 'version' is not the version of the languages involved, but
+    //                 the version of the client environment.
+    //                 Use EShClientNone and version of 0 if there is no client, e.g.
+    //                 for validation mode.
+    //
+    //                 See EShTargetClientVersion for choices.
+    //
+    // setEnvTarget:   The language to translate to when generating code, and that
+    //                 language's version.
+    //                 Use EShTargetNone and version of 0 if there is no client, e.g.
+    //                 for validation mode.
+    //
+    void setEnvInput(EShSource lang, EShLanguage envStage, EShClient client, int version)
+    {
+        environment.input.languageFamily = lang;
+        environment.input.stage = envStage;
+        environment.input.dialect = client;
+        environment.input.dialectVersion = version;
+    }
+    void setEnvClient(EShClient client, EShTargetClientVersion version)
+    {
+        environment.client.client = client;
+        environment.client.version = version;
+    }
+    void setEnvTarget(EShTargetLanguage lang, EShTargetLanguageVersion version)
+    {
+        environment.target.language = lang;
+        environment.target.version = version;
+    }
+
+    void getStrings(const char* const* &s, int& n) { s = strings; n = numStrings; }
+
+#ifdef ENABLE_HLSL
+    void setEnvTargetHlslFunctionality1() { environment.target.hlslFunctionality1 = true; }
+    bool getEnvTargetHlslFunctionality1() const { return environment.target.hlslFunctionality1; }
+#else
+    bool getEnvTargetHlslFunctionality1() const { return false; }
+#endif
+
+    void setEnvInputVulkanRulesRelaxed() { environment.input.vulkanRulesRelaxed = true; }
+    bool getEnvInputVulkanRulesRelaxed() const { return environment.input.vulkanRulesRelaxed; }
+
+    void setCompileOnly() { compileOnly = true; }
+    bool getCompileOnly() const { return compileOnly; }
+
+    // Interface to #include handlers.
+    //
+    // To support #include, a client of Glslang does the following:
+    // 1. Call setStringsWithNames to set the source strings and associated
+    //    names.  For example, the names could be the names of the files
+    //    containing the shader sources.
+    // 2. Call parse with an Includer.
+    //
+    // When the Glslang parser encounters an #include directive, it calls
+    // the Includer's include method with the requested include name
+    // together with the current string name.  The returned IncludeResult
+    // contains the fully resolved name of the included source, together
+    // with the source text that should replace the #include directive
+    // in the source stream.  After parsing that source, Glslang will
+    // release the IncludeResult object.
+    class Includer {
+    public:
+        // An IncludeResult contains the resolved name and content of a source
+        // inclusion.
+        struct IncludeResult {
+            IncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength, void* userData) :
+                headerName(headerName), headerData(headerData), headerLength(headerLength), userData(userData) { }
+            // For a successful inclusion, the fully resolved name of the requested
+            // include.  For example, in a file system-based includer, full resolution
+            // should convert a relative path name into an absolute path name.
+            // For a failed inclusion, this is an empty string.
+            const std::string headerName;
+            // The content and byte length of the requested inclusion.  The
+            // Includer producing this IncludeResult retains ownership of the
+            // storage.
+            // For a failed inclusion, the header
+            // field points to a string containing error details.
+            const char* const headerData;
+            const size_t headerLength;
+            // Include resolver's context.
+            void* userData;
+        protected:
+            IncludeResult& operator=(const IncludeResult&);
+            IncludeResult();
+        };
+
+        // For both include methods below:
+        //
+        // Resolves an inclusion request by name, current source name,
+        // and include depth.
+        // On success, returns an IncludeResult containing the resolved name
+        // and content of the include.
+        // On failure, returns a nullptr, or an IncludeResult
+        // with an empty string for the headerName and error details in the
+        // header field.
+        // The Includer retains ownership of the contents
+        // of the returned IncludeResult value, and those contents must
+        // remain valid until the releaseInclude method is called on that
+        // IncludeResult object.
+        //
+        // Note "local" vs. "system" is not an "either/or": "local" is an
+        // extra thing to do over "system". Both might get called, as per
+        // the C++ specification.
+
+        // For the "system" or <>-style includes; search the "system" paths.
+        virtual IncludeResult* includeSystem(const char* /*headerName*/,
+                                             const char* /*includerName*/,
+                                             size_t /*inclusionDepth*/) { return nullptr; }
+
+        // For the "local"-only aspect of a "" include. Should not search in the
+        // "system" paths, because on returning a failure, the parser will
+        // call includeSystem() to look in the "system" locations.
+        virtual IncludeResult* includeLocal(const char* /*headerName*/,
+                                            const char* /*includerName*/,
+                                            size_t /*inclusionDepth*/) { return nullptr; }
+
+        // Signals that the parser will no longer use the contents of the
+        // specified IncludeResult.
+        virtual void releaseInclude(IncludeResult*) = 0;
+        virtual ~Includer() {}
+    };
+
+    // Fail all Includer searches
+    class ForbidIncluder : public Includer {
+    public:
+        virtual void releaseInclude(IncludeResult*) override { }
+    };
+
+    GLSLANG_EXPORT bool parse(
+        const TBuiltInResource*, int defaultVersion, EProfile defaultProfile,
+        bool forceDefaultVersionAndProfile, bool forwardCompatible,
+        EShMessages, Includer&);
+
+    bool parse(const TBuiltInResource* res, int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile,
+               bool forwardCompatible, EShMessages messages)
+    {
+        TShader::ForbidIncluder includer;
+        return parse(res, defaultVersion, defaultProfile, forceDefaultVersionAndProfile, forwardCompatible, messages, includer);
+    }
+
+    // Equivalent to parse() without a default profile and without forcing defaults.
+    bool parse(const TBuiltInResource* builtInResources, int defaultVersion, bool forwardCompatible, EShMessages messages)
+    {
+        return parse(builtInResources, defaultVersion, ENoProfile, false, forwardCompatible, messages);
+    }
+
+    bool parse(const TBuiltInResource* builtInResources, int defaultVersion, bool forwardCompatible, EShMessages messages,
+               Includer& includer)
+    {
+        return parse(builtInResources, defaultVersion, ENoProfile, false, forwardCompatible, messages, includer);
+    }
+
+    // NOTE: Doing just preprocessing to obtain a correct preprocessed shader string
+    // is not an officially supported or fully working path.
+    GLSLANG_EXPORT bool preprocess(
+        const TBuiltInResource* builtInResources, int defaultVersion,
+        EProfile defaultProfile, bool forceDefaultVersionAndProfile,
+        bool forwardCompatible, EShMessages message, std::string* outputString,
+        Includer& includer);
+
+    GLSLANG_EXPORT const char* getInfoLog();
+    GLSLANG_EXPORT const char* getInfoDebugLog();
+    EShLanguage getStage() const { return stage; }
+    TIntermediate* getIntermediate() const { return intermediate; }
+
+protected:
+    TPoolAllocator* pool;
+    EShLanguage stage;
+    TCompiler* compiler;
+    TIntermediate* intermediate;
+    TInfoSink* infoSink;
+    // strings and lengths follow the standard for glShaderSource:
+    //     strings is an array of numStrings pointers to string data.
+    //     lengths can be null, but if not it is an array of numStrings
+    //         integers containing the length of the associated strings.
+    //         if lengths is null or lengths[n] < 0  the associated strings[n] is
+    //         assumed to be null-terminated.
+    // stringNames is the optional names for all the strings. If stringNames
+    // is null, then none of the strings has name. If a certain element in
+    // stringNames is null, then the corresponding string does not have name.
+    const char* const* strings;      // explicit code to compile, see previous comment
+    const int* lengths;
+    const char* const* stringNames;
+    int numStrings;                  // size of the above arrays
+    const char* preamble;            // string of implicit code to compile before the explicitly provided code
+
+    // a function in the source string can be renamed FROM this TO the name given in setEntryPoint.
+    std::string sourceEntryPointName;
+
+    // overrides #version in shader source or default version if #version isn't present
+    int overrideVersion;
+
+    TEnvironment environment;
+
+    // Indicates this shader is meant to be used without linking
+    bool compileOnly = false;
+
+    friend class TProgram;
+
+private:
+    TShader& operator=(TShader&);
+};
+
+//
+// A reflection database and its interface, consistent with the OpenGL API reflection queries.
+//
+
+// Data needed for just a single object at the granularity exchanged by the reflection API
+class TObjectReflection {
+public:
+    GLSLANG_EXPORT TObjectReflection(const std::string& pName, const TType& pType, int pOffset, int pGLDefineType, int pSize, int pIndex);
+
+    const TType* getType() const { return type; }
+    GLSLANG_EXPORT int getBinding() const;
+    GLSLANG_EXPORT void dump() const;
+    static TObjectReflection badReflection() { return TObjectReflection(); }
+
+    GLSLANG_EXPORT unsigned int layoutLocation() const;
+
+    std::string name;
+    int offset;
+    int glDefineType;
+    int size;                   // data size in bytes for a block, array size for a (non-block) object that's an array
+    int index;
+    int counterIndex;
+    int numMembers;
+    int arrayStride;            // stride of an array variable
+    int topLevelArraySize;      // size of the top-level variable in a storage buffer member
+    int topLevelArrayStride;    // stride of the top-level variable in a storage buffer member
+    EShLanguageMask stages;
+
+protected:
+    TObjectReflection()
+        : offset(-1), glDefineType(-1), size(-1), index(-1), counterIndex(-1), numMembers(-1), arrayStride(0),
+          topLevelArrayStride(0), stages(EShLanguageMask(0)), type(nullptr)
+    {
+    }
+
+    const TType* type;
+};
+
+class  TReflection;
+class  TIoMapper;
+struct TVarEntryInfo;
+
+// Allows to customize the binding layout after linking.
+// All used uniform variables will invoke at least validateBinding.
+// If validateBinding returned true then the other resolveBinding,
+// resolveSet, and resolveLocation are invoked to resolve the binding
+// and descriptor set index respectively.
+//
+// Invocations happen in a particular order:
+// 1) all shader inputs
+// 2) all shader outputs
+// 3) all uniforms with binding and set already defined
+// 4) all uniforms with binding but no set defined
+// 5) all uniforms with set but no binding defined
+// 6) all uniforms with no binding and no set defined
+//
+// mapIO will use this resolver in two phases. The first
+// phase is a notification phase, calling the corresponging
+// notifiy callbacks, this phase ends with a call to endNotifications.
+// Phase two starts directly after the call to endNotifications
+// and calls all other callbacks to validate and to get the
+// bindings, sets, locations, component and color indices.
+//
+// NOTE: that still limit checks are applied to bindings and sets
+// and may result in an error.
+class TIoMapResolver
+{
+public:
+    virtual ~TIoMapResolver() {}
+
+    // Should return true if the resulting/current binding would be okay.
+    // Basic idea is to do aliasing binding checks with this.
+    virtual bool validateBinding(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current binding should be overridden.
+    // Return -1 if the current binding (including no binding) should be kept.
+    virtual int resolveBinding(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current set should be overridden.
+    // Return -1 if the current set (including no set) should be kept.
+    virtual int resolveSet(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current location should be overridden.
+    // Return -1 if the current location (including no location) should be kept.
+    virtual int resolveUniformLocation(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return true if the resulting/current setup would be okay.
+    // Basic idea is to do aliasing checks and reject invalid semantic names.
+    virtual bool validateInOut(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current location should be overridden.
+    // Return -1 if the current location (including no location) should be kept.
+    virtual int resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current component index should be overridden.
+    // Return -1 if the current component index (including no index) should be kept.
+    virtual int resolveInOutComponent(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Should return a value >= 0 if the current color index should be overridden.
+    // Return -1 if the current color index (including no index) should be kept.
+    virtual int resolveInOutIndex(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Notification of a uniform variable
+    virtual void notifyBinding(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Notification of a in or out variable
+    virtual void notifyInOut(EShLanguage stage, TVarEntryInfo& ent) = 0;
+    // Called by mapIO when it starts its notify pass for the given stage
+    virtual void beginNotifications(EShLanguage stage) = 0;
+    // Called by mapIO when it has finished the notify pass
+    virtual void endNotifications(EShLanguage stage) = 0;
+    // Called by mipIO when it starts its resolve pass for the given stage
+    virtual void beginResolve(EShLanguage stage) = 0;
+    // Called by mapIO when it has finished the resolve pass
+    virtual void endResolve(EShLanguage stage) = 0;
+    // Called by mapIO when it starts its symbol collect for teh given stage
+    virtual void beginCollect(EShLanguage stage) = 0;
+    // Called by mapIO when it has finished the symbol collect
+    virtual void endCollect(EShLanguage stage) = 0;
+    // Called by TSlotCollector to resolve storage locations or bindings
+    virtual void reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) = 0;
+    // Called by TSlotCollector to resolve resource locations or bindings
+    virtual void reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) = 0;
+    // Called by mapIO.addStage to set shader stage mask to mark a stage be added to this pipeline
+    virtual void addStage(EShLanguage stage, TIntermediate& stageIntermediate) = 0;
+};
+
+// I/O mapper
+class TIoMapper {
+public:
+    TIoMapper() {}
+    virtual ~TIoMapper() {}
+    // grow the reflection stage by stage
+    bool virtual addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*);
+    bool virtual doMap(TIoMapResolver*, TInfoSink&) { return true; }
+    bool virtual setAutoPushConstantBlock(const char*, unsigned int, TLayoutPacking) { return false; }
+};
+
+// Get the default GLSL IO mapper
+GLSLANG_EXPORT TIoMapper* GetGlslIoMapper();
+
+// Make one TProgram per set of shaders that will get linked together.  Add all
+// the shaders that are to be linked together.  After calling shader.parse()
+// for all shaders, call link().
+//
+// N.B.: Destruct a linked program *before* destructing the shaders linked into it.
+//
+class TProgram {
+public:
+    GLSLANG_EXPORT TProgram();
+    GLSLANG_EXPORT virtual ~TProgram();
+    void addShader(TShader* shader) { stages[shader->stage].push_back(shader); }
+    std::list<TShader*>& getShaders(EShLanguage stage) { return stages[stage]; }
+    // Link Validation interface
+    GLSLANG_EXPORT bool link(EShMessages);
+    GLSLANG_EXPORT const char* getInfoLog();
+    GLSLANG_EXPORT const char* getInfoDebugLog();
+
+    TIntermediate* getIntermediate(EShLanguage stage) const { return intermediate[stage]; }
+
+    // Reflection Interface
+
+    // call first, to do liveness analysis, index mapping, etc.; returns false on failure
+    GLSLANG_EXPORT bool buildReflection(int opts = EShReflectionDefault);
+    GLSLANG_EXPORT unsigned getLocalSize(int dim) const;                  // return dim'th local size
+    GLSLANG_EXPORT int getReflectionIndex(const char *name) const;
+    GLSLANG_EXPORT int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const;
+    GLSLANG_EXPORT int getNumUniformVariables() const;
+    GLSLANG_EXPORT const TObjectReflection& getUniform(int index) const;
+    GLSLANG_EXPORT int getNumUniformBlocks() const;
+    GLSLANG_EXPORT const TObjectReflection& getUniformBlock(int index) const;
+    GLSLANG_EXPORT int getNumPipeInputs() const;
+    GLSLANG_EXPORT const TObjectReflection& getPipeInput(int index) const;
+    GLSLANG_EXPORT int getNumPipeOutputs() const;
+    GLSLANG_EXPORT const TObjectReflection& getPipeOutput(int index) const;
+    GLSLANG_EXPORT int getNumBufferVariables() const;
+    GLSLANG_EXPORT const TObjectReflection& getBufferVariable(int index) const;
+    GLSLANG_EXPORT int getNumBufferBlocks() const;
+    GLSLANG_EXPORT const TObjectReflection& getBufferBlock(int index) const;
+    GLSLANG_EXPORT int getNumAtomicCounters() const;
+    GLSLANG_EXPORT const TObjectReflection& getAtomicCounter(int index) const;
+
+    // Legacy Reflection Interface - expressed in terms of above interface
+
+    // can be used for glGetProgramiv(GL_ACTIVE_UNIFORMS)
+    int getNumLiveUniformVariables() const             { return getNumUniformVariables(); }
+
+    // can be used for glGetProgramiv(GL_ACTIVE_UNIFORM_BLOCKS)
+    int getNumLiveUniformBlocks() const                { return getNumUniformBlocks(); }
+
+    // can be used for glGetProgramiv(GL_ACTIVE_ATTRIBUTES)
+    int getNumLiveAttributes() const                   { return getNumPipeInputs(); }
+
+    // can be used for glGetUniformIndices()
+    int getUniformIndex(const char *name) const        { return getReflectionIndex(name); }
+
+    int getPipeIOIndex(const char *name, const bool inOrOut) const
+                                                       { return getReflectionPipeIOIndex(name, inOrOut); }
+
+    // can be used for "name" part of glGetActiveUniform()
+    const char *getUniformName(int index) const        { return getUniform(index).name.c_str(); }
+
+    // returns the binding number
+    int getUniformBinding(int index) const             { return getUniform(index).getBinding(); }
+
+    // returns Shaders Stages where a Uniform is present
+    EShLanguageMask getUniformStages(int index) const  { return getUniform(index).stages; }
+
+    // can be used for glGetActiveUniformsiv(GL_UNIFORM_BLOCK_INDEX)
+    int getUniformBlockIndex(int index) const          { return getUniform(index).index; }
+
+    // can be used for glGetActiveUniformsiv(GL_UNIFORM_TYPE)
+    int getUniformType(int index) const                { return getUniform(index).glDefineType; }
+
+    // can be used for glGetActiveUniformsiv(GL_UNIFORM_OFFSET)
+    int getUniformBufferOffset(int index) const        { return getUniform(index).offset; }
+
+    // can be used for glGetActiveUniformsiv(GL_UNIFORM_SIZE)
+    int getUniformArraySize(int index) const           { return getUniform(index).size; }
+
+    // returns a TType*
+    const TType *getUniformTType(int index) const      { return getUniform(index).getType(); }
+
+    // can be used for glGetActiveUniformBlockName()
+    const char *getUniformBlockName(int index) const   { return getUniformBlock(index).name.c_str(); }
+
+    // can be used for glGetActiveUniformBlockiv(UNIFORM_BLOCK_DATA_SIZE)
+    int getUniformBlockSize(int index) const           { return getUniformBlock(index).size; }
+
+    // returns the block binding number
+    int getUniformBlockBinding(int index) const        { return getUniformBlock(index).getBinding(); }
+
+    // returns block index of associated counter.
+    int getUniformBlockCounterIndex(int index) const   { return getUniformBlock(index).counterIndex; }
+
+    // returns a TType*
+    const TType *getUniformBlockTType(int index) const { return getUniformBlock(index).getType(); }
+
+    // can be used for glGetActiveAttrib()
+    const char *getAttributeName(int index) const      { return getPipeInput(index).name.c_str(); }
+
+    // can be used for glGetActiveAttrib()
+    int getAttributeType(int index) const              { return getPipeInput(index).glDefineType; }
+
+    // returns a TType*
+    const TType *getAttributeTType(int index) const    { return getPipeInput(index).getType(); }
+
+    GLSLANG_EXPORT void dumpReflection();
+
+    // Get the IO resolver to use for mapIO
+    GLSLANG_EXPORT TIoMapResolver* getGlslIoResolver(EShLanguage stage);
+
+    // I/O mapping: apply base offsets and map live unbound variables
+    // If resolver is not provided it uses the previous approach
+    // and respects auto assignment and offsets.
+    GLSLANG_EXPORT bool mapIO(TIoMapResolver* pResolver = nullptr, TIoMapper* pIoMapper = nullptr);
+
+protected:
+    GLSLANG_EXPORT bool linkStage(EShLanguage, EShMessages);
+    GLSLANG_EXPORT bool crossStageCheck(EShMessages);
+
+    TPoolAllocator* pool;
+    std::list<TShader*> stages[EShLangCount];
+    TIntermediate* intermediate[EShLangCount];
+    bool newedIntermediate[EShLangCount];      // track which intermediate were "new" versus reusing a singleton unit in a stage
+    TInfoSink* infoSink;
+    TReflection* reflection;
+    bool linked;
+
+private:
+    TProgram(TProgram&);
+    TProgram& operator=(TProgram&);
+};
+
+} // end namespace glslang
+
+#endif // _COMPILER_INTERFACE_INCLUDED_

+/**
+BSD 2-Clause License
+
+Copyright (c) 2020, Travis Fort
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**/
+
+#ifndef _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_
+#define _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_
+
+#include "../Include/glslang_c_interface.h"
+#include "../Include/visibility.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns a struct that can be use to create custom resource values.
+GLSLANG_EXPORT glslang_resource_t* glslang_resource(void);
+
+// These are the default resources for TBuiltInResources, used for both
+//  - parsing this string for the case where the user didn't supply one,
+//  - dumping out a template for user construction of a config file.
+GLSLANG_EXPORT const glslang_resource_t* glslang_default_resource(void);
+
+// Returns the DefaultTBuiltInResource as a human-readable string.
+// NOTE: User is responsible for freeing this string.
+GLSLANG_EXPORT const char* glslang_default_resource_string();
+
+// Decodes the resource limits from |config| to |resources|.
+GLSLANG_EXPORT void glslang_decode_resource_limits(glslang_resource_t* resources, char* config);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _STAND_ALONE_RESOURCE_LIMITS_C_INCLUDED_

+//
+// Copyright (C) 2014 LunarG, Inc.
+// Copyright (C) 2015-2018 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "Logger.h"
+#include "glslang/Include/visibility.h"
+
+namespace glslang {
+class TIntermediate;
+
+struct SpvOptions {
+    bool generateDebugInfo {false};
+    bool stripDebugInfo {false};
+    bool disableOptimizer {true};
+    bool optimizeSize {false};
+    bool disassemble {false};
+    bool validate {false};
+    bool emitNonSemanticShaderDebugInfo {false};
+    bool emitNonSemanticShaderDebugSource{ false };
+    bool compileOnly{false};
+    bool optimizerAllowExpandedIDBound{false};
+};
+
+GLSLANG_EXPORT void GetSpirvVersion(std::string&);
+GLSLANG_EXPORT int GetSpirvGeneratorVersion();
+GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                 SpvOptions* options = nullptr);
+GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                 spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
+GLSLANG_EXPORT bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
+GLSLANG_EXPORT bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
+
+}

+//
+// Copyright (C) 2016 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of Google Inc. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GLSLANG_SPIRV_LOGGER_H
+#define GLSLANG_SPIRV_LOGGER_H
+
+#include <string>
+#include <vector>
+#include "glslang/Include/visibility.h"
+
+namespace spv {
+
+// A class for holding all SPIR-V build status messages, including
+// missing/TBD functionalities, warnings, and errors.
+class GLSLANG_EXPORT SpvBuildLogger {
+public:
+    SpvBuildLogger() {}
+
+    // Registers a TBD functionality.
+    void tbdFunctionality(const std::string& f);
+    // Registers a missing functionality.
+    void missingFunctionality(const std::string& f);
+
+    // Logs a warning.
+    void warning(const std::string& w) { warnings.push_back(w); }
+    // Logs an error.
+    void error(const std::string& e) { errors.push_back(e); }
+
+    // Returns all messages accumulated in the order of:
+    // TBD functionalities, missing functionalities, warnings, errors.
+    std::string getAllMessages() const;
+
+private:
+    SpvBuildLogger(const SpvBuildLogger&);
+
+    std::vector<std::string> tbdFeatures;
+    std::vector<std::string> missingFeatures;
+    std::vector<std::string> warnings;
+    std::vector<std::string> errors;
+};
+
+} // end spv namespace
+
+#endif // GLSLANG_SPIRV_LOGGER_H

+//
+// Copyright (C) 2015 LunarG, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+
+#ifndef SPIRVREMAPPER_H
+#define SPIRVREMAPPER_H
+
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include <exception>
+
+#ifdef GLSLANG_IS_SHARED_LIBRARY
+    #ifdef _WIN32
+        #ifdef GLSLANG_EXPORTING
+            #define GLSLANG_EXPORT __declspec(dllexport)
+        #else
+            #define GLSLANG_EXPORT __declspec(dllimport)
+        #endif
+    #elif __GNUC__ >= 4
+        #define GLSLANG_EXPORT __attribute__((visibility("default")))
+    #endif
+#endif // GLSLANG_IS_SHARED_LIBRARY
+#ifndef GLSLANG_EXPORT
+#define GLSLANG_EXPORT
+#endif
+
+namespace spv {
+
+class spirvbin_base_t
+{
+public:
+   enum Options {
+      NONE          = 0,
+      STRIP         = (1<<0),
+      MAP_TYPES     = (1<<1),
+      MAP_NAMES     = (1<<2),
+      MAP_FUNCS     = (1<<3),
+      DCE_FUNCS     = (1<<4),
+      DCE_VARS      = (1<<5),
+      DCE_TYPES     = (1<<6),
+      OPT_LOADSTORE = (1<<7),
+      OPT_FWD_LS    = (1<<8), // EXPERIMENTAL: PRODUCES INVALID SCHEMA-0 SPIRV
+      MAP_ALL       = (MAP_TYPES | MAP_NAMES | MAP_FUNCS),
+      DCE_ALL       = (DCE_FUNCS | DCE_VARS | DCE_TYPES),
+      OPT_ALL       = (OPT_LOADSTORE),
+
+      ALL_BUT_STRIP = (MAP_ALL | DCE_ALL | OPT_ALL),
+      DO_EVERYTHING = (STRIP | ALL_BUT_STRIP)
+   };
+};
+
+} // namespace SPV
+
+#include <functional>
+#include <cstdint>
+#include <unordered_map>
+#include <unordered_set>
+#include <map>
+#include <set>
+#include <cassert>
+
+#include "spirv.hpp"
+
+namespace spv {
+
+static inline constexpr Id NoResult = 0;
+
+// class to hold SPIR-V binary data for remapping, DCE, and debug stripping
+class GLSLANG_EXPORT spirvbin_t : public spirvbin_base_t
+{
+public:
+   spirvbin_t(int verbose = 0) : entryPoint(spv::NoResult), largestNewId(0), verbose(verbose), errorLatch(false)
+   { }
+
+   virtual ~spirvbin_t() { }
+
+   // remap on an existing binary in memory
+   void remap(std::vector<std::uint32_t>& spv, const std::vector<std::string>& whiteListStrings,
+              std::uint32_t opts = DO_EVERYTHING);
+
+   // remap on an existing binary in memory - legacy interface without white list
+   void remap(std::vector<std::uint32_t>& spv, std::uint32_t opts = DO_EVERYTHING);
+
+   // Type for error/log handler functions
+   typedef std::function<void(const std::string&)> errorfn_t;
+   typedef std::function<void(const std::string&)> logfn_t;
+
+   // Register error/log handling functions (can be lambda fn / functor / etc)
+   static void registerErrorHandler(errorfn_t handler) { errorHandler = handler; }
+   static void registerLogHandler(logfn_t handler)     { logHandler   = handler; }
+
+protected:
+   // This can be overridden to provide other message behavior if needed
+   virtual void msg(int minVerbosity, int indent, const std::string& txt) const;
+
+private:
+   // Local to global, or global to local ID map
+   typedef std::unordered_map<spv::Id, spv::Id> idmap_t;
+   typedef std::unordered_set<spv::Id>          idset_t;
+   typedef std::unordered_map<spv::Id, int>     blockmap_t;
+
+   void remap(std::uint32_t opts = DO_EVERYTHING);
+
+   // Map of names to IDs
+   typedef std::unordered_map<std::string, spv::Id> namemap_t;
+
+   typedef std::uint32_t spirword_t;
+
+   typedef std::pair<unsigned, unsigned> range_t;
+   typedef std::function<void(spv::Id&)>                idfn_t;
+   typedef std::function<bool(spv::Op, unsigned start)> instfn_t;
+
+   // Special Values for ID map:
+   static const spv::Id unmapped;     // unchanged from default value
+   static const spv::Id unused;       // unused ID
+   static const int     header_size;  // SPIR header = 5 words
+
+   class id_iterator_t;
+
+   // For mapping type entries between different shaders
+   typedef std::vector<spirword_t>        typeentry_t;
+   typedef std::map<spv::Id, typeentry_t> globaltypes_t;
+
+   // A set that preserves position order, and a reverse map
+   typedef std::set<int>                    posmap_t;
+   typedef std::unordered_map<spv::Id, int> posmap_rev_t;
+
+   // Maps and ID to the size of its base type, if known.
+   typedef std::unordered_map<spv::Id, unsigned> typesize_map_t;
+
+   // handle error
+   void error(const std::string& txt) const { errorLatch = true; errorHandler(txt); }
+
+   bool     isConstOp(spv::Op opCode)      const;
+   bool     isTypeOp(spv::Op opCode)       const;
+   bool     isStripOp(spv::Op opCode)      const;
+   bool     isFlowCtrl(spv::Op opCode)     const;
+   range_t  literalRange(spv::Op opCode)   const;
+   range_t  typeRange(spv::Op opCode)      const;
+   range_t  constRange(spv::Op opCode)     const;
+   unsigned typeSizeInWords(spv::Id id)    const;
+   unsigned idTypeSizeInWords(spv::Id id)  const;
+
+   bool isStripOp(spv::Op opCode, unsigned start) const;
+
+   spv::Id&        asId(unsigned word)                { return spv[word]; }
+   const spv::Id&  asId(unsigned word)          const { return spv[word]; }
+   spv::Op         asOpCode(unsigned word)      const { return opOpCode(spv[word]); }
+   std::uint32_t   asOpCodeHash(unsigned word);
+   spv::Decoration asDecoration(unsigned word)  const { return spv::Decoration(spv[word]); }
+   unsigned        asWordCount(unsigned word)   const { return opWordCount(spv[word]); }
+   spv::Id         asTypeConstId(unsigned word) const { return asId(word + (isTypeOp(asOpCode(word)) ? 1 : 2)); }
+   unsigned        idPos(spv::Id id)            const;
+
+   static unsigned opWordCount(spirword_t data) { return data >> spv::WordCountShift; }
+   static spv::Op  opOpCode(spirword_t data)    { return spv::Op(data & spv::OpCodeMask); }
+
+   // Header access & set methods
+   spirword_t  magic()    const       { return spv[0]; } // return magic number
+   spirword_t  bound()    const       { return spv[3]; } // return Id bound from header
+   spirword_t  bound(spirword_t b)    { return spv[3] = b; }
+   spirword_t  genmagic() const       { return spv[2]; } // generator magic
+   spirword_t  genmagic(spirword_t m) { return spv[2] = m; }
+   spirword_t  schemaNum() const      { return spv[4]; } // schema number from header
+
+   // Mapping fns: get
+   spv::Id     localId(spv::Id id) const { return idMapL[id]; }
+
+   // Mapping fns: set
+   inline spv::Id   localId(spv::Id id, spv::Id newId);
+   void             countIds(spv::Id id);
+
+   // Return next unused new local ID.
+   // NOTE: boost::dynamic_bitset would be more efficient due to find_next(),
+   // which std::vector<bool> doens't have.
+   inline spv::Id   nextUnusedId(spv::Id id);
+
+   void buildLocalMaps();
+   std::string literalString(unsigned word) const; // Return literal as a std::string
+   int literalStringWords(const std::string& str) const { return (int(str.size())+4)/4; }
+
+   bool isNewIdMapped(spv::Id newId)   const { return isMapped(newId);            }
+   bool isOldIdUnmapped(spv::Id oldId) const { return localId(oldId) == unmapped; }
+   bool isOldIdUnused(spv::Id oldId)   const { return localId(oldId) == unused;   }
+   bool isOldIdMapped(spv::Id oldId)   const { return !isOldIdUnused(oldId) && !isOldIdUnmapped(oldId); }
+   bool isFunction(spv::Id oldId)      const { return fnPos.find(oldId) != fnPos.end(); }
+
+   // bool    matchType(const globaltypes_t& globalTypes, spv::Id lt, spv::Id gt) const;
+   // spv::Id findType(const globaltypes_t& globalTypes, spv::Id lt) const;
+   std::uint32_t hashType(unsigned typeStart) const;
+
+   spirvbin_t& process(instfn_t, idfn_t, unsigned begin = 0, unsigned end = 0);
+   int         processInstruction(unsigned word, instfn_t, idfn_t);
+
+   void        validate() const;
+   void        mapTypeConst();
+   void        mapFnBodies();
+   void        optLoadStore();
+   void        dceFuncs();
+   void        dceVars();
+   void        dceTypes();
+   void        mapNames();
+   void        foldIds();  // fold IDs to smallest space
+   void        forwardLoadStores(); // load store forwarding (EXPERIMENTAL)
+   void        offsetIds(); // create relative offset IDs
+
+   void        applyMap();            // remap per local name map
+   void        mapRemainder();        // map any IDs we haven't touched yet
+   void        stripDebug();          // strip all debug info
+   void        stripDeadRefs();       // strips debug info for now-dead references after DCE
+   void        strip();               // remove debug symbols
+
+   std::vector<spirword_t> spv;      // SPIR words
+
+   std::vector<std::string> stripWhiteList;
+
+   namemap_t               nameMap;  // ID names from OpName
+
+   // Since we want to also do binary ops, we can't use std::vector<bool>.  we could use
+   // boost::dynamic_bitset, but we're trying to avoid a boost dependency.
+   typedef std::uint64_t bits_t;
+   std::vector<bits_t> mapped; // which new IDs have been mapped
+   static const int mBits = sizeof(bits_t) * 4;
+
+   bool isMapped(spv::Id id) const  { return id < maxMappedId() && ((mapped[id/mBits] & (1LL<<(id%mBits))) != 0); }
+   void setMapped(spv::Id id) { resizeMapped(id); mapped[id/mBits] |= (1LL<<(id%mBits)); }
+   void resizeMapped(spv::Id id) { if (id >= maxMappedId()) mapped.resize(id/mBits+1, 0); }
+   size_t maxMappedId() const { return mapped.size() * mBits; }
+
+   // Add a strip range for a given instruction starting at 'start'
+   // Note: avoiding brace initializers to please older versions os MSVC.
+   void stripInst(unsigned start) { stripRange.push_back(range_t(start, start + asWordCount(start))); }
+
+   // Function start and end.  use unordered_map because we'll have
+   // many fewer functions than IDs.
+   std::unordered_map<spv::Id, range_t> fnPos;
+
+   // Which functions are called, anywhere in the module, with a call count
+   std::unordered_map<spv::Id, int> fnCalls;
+
+   posmap_t       typeConstPos;  // word positions that define types & consts (ordered)
+   posmap_rev_t   idPosR;        // reverse map from IDs to positions
+   typesize_map_t idTypeSizeMap; // maps each ID to its type size, if known.
+
+   std::vector<spv::Id>  idMapL;   // ID {M}ap from {L}ocal to {G}lobal IDs
+
+   spv::Id entryPoint;      // module entry point
+   spv::Id largestNewId;    // biggest new ID we have mapped anything to
+
+   // Sections of the binary to strip, given as [begin,end)
+   std::vector<range_t> stripRange;
+
+   // processing options:
+   std::uint32_t options;
+   int           verbose;     // verbosity level
+
+   // Error latch: this is set if the error handler is ever executed.  It would be better to
+   // use a try/catch block and throw, but that's not desired for certain environments, so
+   // this is the alternative.
+   mutable bool errorLatch;
+
+   static errorfn_t errorHandler;
+   static logfn_t   logHandler;
+};
+
+} // namespace SPV
+
+#endif // SPIRVREMAPPER_H

+//
+// Copyright (C) 2014-2016 LunarG, Inc.
+// Copyright (C) 2018 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Call into SPIRV-Tools to disassemble, validate, and optimize.
+//
+
+#pragma once
+#ifndef GLSLANG_SPV_TOOLS_H
+#define GLSLANG_SPV_TOOLS_H
+
+#if ENABLE_OPT
+#include <vector>
+#include <ostream>
+#include <unordered_set>
+#include "spirv-tools/libspirv.h"
+#endif
+
+#include "glslang/MachineIndependent/Versions.h"
+#include "glslang/Include/visibility.h"
+#include "GlslangToSpv.h"
+#include "Logger.h"
+
+namespace glslang {
+
+#if ENABLE_OPT
+
+class TIntermediate;
+
+// Translate glslang's view of target versioning to what SPIRV-Tools uses.
+GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
+GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const glslang::TIntermediate& intermediate, spv::SpvBuildLogger* logger);
+
+// Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
+GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
+
+// Use the SPIRV-Tools disassembler to print SPIR-V with a provided SPIR-V environment.
+GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv,
+                                          spv_target_env requested_context);
+
+// Apply the SPIRV-Tools validator to generated SPIR-V.
+GLSLANG_EXPORT void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                       spv::SpvBuildLogger*, bool prelegalization);
+
+// Apply the SPIRV-Tools optimizer to generated SPIR-V.  HLSL SPIR-V is legalized in the process.
+GLSLANG_EXPORT void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                        spv::SpvBuildLogger*, const SpvOptions*);
+
+// Apply the SPIRV-Tools EliminateDeadInputComponents pass to generated SPIR-V. Put result in |spirv|.
+GLSLANG_EXPORT void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                           spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools AnalyzeDeadOutputStores pass to generated SPIR-V. Put result in |live_locs|.
+// Return true if the result is valid.
+GLSLANG_EXPORT bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                      std::unordered_set<uint32_t>* live_locs,
+                                                      std::unordered_set<uint32_t>* live_builtins,
+                                                      spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools EliminateDeadOutputStores and AggressiveDeadCodeElimination passes to generated SPIR-V using
+// |live_locs|. Put result in |spirv|.
+GLSLANG_EXPORT void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                        std::unordered_set<uint32_t>* live_locs,
+                                                        std::unordered_set<uint32_t>* live_builtins,
+                                                        spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
+// SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
+// optimization is disabled.
+GLSLANG_EXPORT void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
+                                             std::vector<unsigned int>& spirv, spv::SpvBuildLogger*);
+
+#endif
+
+} // end namespace glslang
+
+#endif // GLSLANG_SPV_TOOLS_H

+//
+// Copyright (C) 2014-2015 LunarG, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Disassembler for SPIR-V.
+//
+
+#pragma once
+#ifndef disassembler_H
+#define disassembler_H
+
+#include <iostream>
+#include <vector>
+
+#include "glslang/Include/visibility.h"
+
+namespace spv {
+
+    // disassemble with glslang custom disassembler
+    GLSLANG_EXPORT void Disassemble(std::ostream& out, const std::vector<unsigned int>&);
+
+}  // end namespace spv
+
+#endif // disassembler_H

+// Copyright (C) 2020 The Khronos Group Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of The Khronos Group Inc. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GLSLANG_BUILD_INFO
+#define GLSLANG_BUILD_INFO
+
+#define GLSLANG_VERSION_MAJOR 15
+#define GLSLANG_VERSION_MINOR 1
+#define GLSLANG_VERSION_PATCH 0
+#define GLSLANG_VERSION_FLAVOR ""
+
+#define GLSLANG_VERSION_GREATER_THAN(major, minor, patch) \
+    ((GLSLANG_VERSION_MAJOR) > (major) || ((major) == GLSLANG_VERSION_MAJOR && \
+    ((GLSLANG_VERSION_MINOR) > (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
+     (GLSLANG_VERSION_PATCH) > (patch)))))
+
+#define GLSLANG_VERSION_GREATER_OR_EQUAL_TO(major, minor, patch) \
+    ((GLSLANG_VERSION_MAJOR) > (major) || ((major) == GLSLANG_VERSION_MAJOR && \
+    ((GLSLANG_VERSION_MINOR) > (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
+     (GLSLANG_VERSION_PATCH >= (patch))))))
+
+#define GLSLANG_VERSION_LESS_THAN(major, minor, patch) \
+    ((GLSLANG_VERSION_MAJOR) < (major) || ((major) == GLSLANG_VERSION_MAJOR && \
+    ((GLSLANG_VERSION_MINOR) < (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
+     (GLSLANG_VERSION_PATCH) < (patch)))))
+
+#define GLSLANG_VERSION_LESS_OR_EQUAL_TO(major, minor, patch) \
+    ((GLSLANG_VERSION_MAJOR) < (major) || ((major) == GLSLANG_VERSION_MAJOR && \
+    ((GLSLANG_VERSION_MINOR) < (minor) || ((minor) == GLSLANG_VERSION_MINOR && \
+     (GLSLANG_VERSION_PATCH <= (patch))))))
+
+#endif // GLSLANG_BUILD_INFO

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_ALLOCATOR_H
+#define NCNN_ALLOCATOR_H
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+#include "platform.h"
+
+#include <stdlib.h>
+
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 26
+#include <android/hardware_buffer.h>
+#endif // __ANDROID_API__ >= 26
+#endif // NCNN_PLATFORM_API
+
+namespace ncnn {
+
+// the alignment of all the allocated buffers
+#if NCNN_AVX512
+#define NCNN_MALLOC_ALIGN 64
+#elif NCNN_AVX
+#define NCNN_MALLOC_ALIGN 32
+#else
+#define NCNN_MALLOC_ALIGN 16
+#endif
+
+// we have some optimized kernels that may overread buffer a bit in loop
+// it is common to interleave next-loop data load with arithmetic instructions
+// allocating more bytes keeps us safe from SEGV_ACCERR failure
+#define NCNN_MALLOC_OVERREAD 64
+
+// Aligns a pointer to the specified number of bytes
+// ptr Aligned pointer
+// n Alignment size that must be a power of two
+template<typename _Tp>
+static NCNN_FORCEINLINE _Tp* alignPtr(_Tp* ptr, int n = (int)sizeof(_Tp))
+{
+    return (_Tp*)(((size_t)ptr + n - 1) & -n);
+}
+
+// Aligns a buffer size to the specified number of bytes
+// The function returns the minimum number that is greater or equal to sz and is divisible by n
+// sz Buffer size to align
+// n Alignment size that must be a power of two
+static NCNN_FORCEINLINE size_t alignSize(size_t sz, int n)
+{
+    return (sz + n - 1) & -n;
+}
+
+static NCNN_FORCEINLINE void* fastMalloc(size_t size)
+{
+#if _MSC_VER
+    return _aligned_malloc(size, NCNN_MALLOC_ALIGN);
+#elif (defined(__unix__) || defined(__APPLE__)) && _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
+    void* ptr = 0;
+    if (posix_memalign(&ptr, NCNN_MALLOC_ALIGN, size + NCNN_MALLOC_OVERREAD))
+        ptr = 0;
+    return ptr;
+#elif __ANDROID__ && __ANDROID_API__ < 17
+    return memalign(NCNN_MALLOC_ALIGN, size + NCNN_MALLOC_OVERREAD);
+#else
+    unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + NCNN_MALLOC_ALIGN + NCNN_MALLOC_OVERREAD);
+    if (!udata)
+        return 0;
+    unsigned char** adata = alignPtr((unsigned char**)udata + 1, NCNN_MALLOC_ALIGN);
+    adata[-1] = udata;
+    return adata;
+#endif
+}
+
+static NCNN_FORCEINLINE void fastFree(void* ptr)
+{
+    if (ptr)
+    {
+#if _MSC_VER
+        _aligned_free(ptr);
+#elif (defined(__unix__) || defined(__APPLE__)) && _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
+        free(ptr);
+#elif __ANDROID__ && __ANDROID_API__ < 17
+        free(ptr);
+#else
+        unsigned char* udata = ((unsigned char**)ptr)[-1];
+        free(udata);
+#endif
+    }
+}
+
+#if NCNN_THREADS
+// exchange-add operation for atomic operations on reference counters
+#if defined __riscv && !defined __riscv_atomic
+// riscv target without A extension
+static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
+{
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#elif defined __INTEL_COMPILER && !(defined WIN32 || defined _WIN32)
+// atomic increment on the linux version of the Intel(tm) compiler
+#define NCNN_XADD(addr, delta) (int)_InterlockedExchangeAdd(const_cast<void*>(reinterpret_cast<volatile void*>(addr)), delta)
+#elif defined __GNUC__
+#if defined __clang__ && __clang_major__ >= 3 && !defined __ANDROID__ && !defined __EMSCRIPTEN__ && !defined(__CUDACC__)
+#ifdef __ATOMIC_ACQ_REL
+#define NCNN_XADD(addr, delta) __c11_atomic_fetch_add((_Atomic(int)*)(addr), delta, __ATOMIC_ACQ_REL)
+#else
+#define NCNN_XADD(addr, delta) __atomic_fetch_add((_Atomic(int)*)(addr), delta, 4)
+#endif
+#else
+#if defined __ATOMIC_ACQ_REL && !defined __clang__
+// version for gcc >= 4.7
+#define NCNN_XADD(addr, delta) (int)__atomic_fetch_add((unsigned*)(addr), (unsigned)(delta), __ATOMIC_ACQ_REL)
+#else
+#define NCNN_XADD(addr, delta) (int)__sync_fetch_and_add((unsigned*)(addr), (unsigned)(delta))
+#endif
+#endif
+#elif defined _MSC_VER && !defined RC_INVOKED
+#define NCNN_XADD(addr, delta) (int)_InterlockedExchangeAdd((long volatile*)addr, delta)
+#else
+// thread-unsafe branch
+static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
+{
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#endif
+#else  // NCNN_THREADS
+static NCNN_FORCEINLINE int NCNN_XADD(int* addr, int delta)
+{
+    int tmp = *addr;
+    *addr += delta;
+    return tmp;
+}
+#endif // NCNN_THREADS
+
+class NCNN_EXPORT Allocator
+{
+public:
+    virtual ~Allocator();
+    virtual void* fastMalloc(size_t size) = 0;
+    virtual void fastFree(void* ptr) = 0;
+};
+
+class PoolAllocatorPrivate;
+class NCNN_EXPORT PoolAllocator : public Allocator
+{
+public:
+    PoolAllocator();
+    ~PoolAllocator();
+
+    // ratio range 0 ~ 1
+    // default cr = 0
+    void set_size_compare_ratio(float scr);
+
+    // budget drop threshold
+    // default threshold = 10
+    void set_size_drop_threshold(size_t);
+
+    // release all budgets immediately
+    void clear();
+
+    virtual void* fastMalloc(size_t size);
+    virtual void fastFree(void* ptr);
+
+private:
+    PoolAllocator(const PoolAllocator&);
+    PoolAllocator& operator=(const PoolAllocator&);
+
+private:
+    PoolAllocatorPrivate* const d;
+};
+
+class UnlockedPoolAllocatorPrivate;
+class NCNN_EXPORT UnlockedPoolAllocator : public Allocator
+{
+public:
+    UnlockedPoolAllocator();
+    ~UnlockedPoolAllocator();
+
+    // ratio range 0 ~ 1
+    // default cr = 0
+    void set_size_compare_ratio(float scr);
+
+    // budget drop threshold
+    // default threshold = 10
+    void set_size_drop_threshold(size_t);
+
+    // release all budgets immediately
+    void clear();
+
+    virtual void* fastMalloc(size_t size);
+    virtual void fastFree(void* ptr);
+
+private:
+    UnlockedPoolAllocator(const UnlockedPoolAllocator&);
+    UnlockedPoolAllocator& operator=(const UnlockedPoolAllocator&);
+
+private:
+    UnlockedPoolAllocatorPrivate* const d;
+};
+
+#if NCNN_VULKAN
+
+class VulkanDevice;
+
+class NCNN_EXPORT VkBufferMemory
+{
+public:
+    VkBuffer buffer;
+
+    // the base offset assigned by allocator
+    size_t offset;
+    size_t capacity;
+
+    VkDeviceMemory memory;
+    void* mapped_ptr;
+
+    // buffer state, modified by command functions internally
+    mutable VkAccessFlags access_flags;
+    mutable VkPipelineStageFlags stage_flags;
+
+    // initialize and modified by mat
+    int refcount;
+};
+
+class NCNN_EXPORT VkImageMemory
+{
+public:
+    VkImage image;
+    VkImageView imageview;
+
+    // underlying info assigned by allocator
+    int width;
+    int height;
+    int depth;
+    VkFormat format;
+
+    VkDeviceMemory memory;
+    void* mapped_ptr;
+
+    // the base offset assigned by allocator
+    size_t bind_offset;
+    size_t bind_capacity;
+
+    // image state, modified by command functions internally
+    mutable VkAccessFlags access_flags;
+    mutable VkImageLayout image_layout;
+    mutable VkPipelineStageFlags stage_flags;
+
+    // in-execution state, modified by command functions internally
+    mutable int command_refcount;
+
+    // initialize and modified by mat
+    int refcount;
+};
+
+class NCNN_EXPORT VkAllocator
+{
+public:
+    explicit VkAllocator(const VulkanDevice* _vkdev);
+    virtual ~VkAllocator();
+
+    virtual void clear();
+
+    virtual VkBufferMemory* fastMalloc(size_t size) = 0;
+    virtual void fastFree(VkBufferMemory* ptr) = 0;
+    virtual int flush(VkBufferMemory* ptr);
+    virtual int invalidate(VkBufferMemory* ptr);
+
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack) = 0;
+    virtual void fastFree(VkImageMemory* ptr) = 0;
+
+public:
+    const VulkanDevice* vkdev;
+    uint32_t buffer_memory_type_index;
+    uint32_t image_memory_type_index;
+    uint32_t reserved_type_index;
+    bool mappable;
+    bool coherent;
+
+protected:
+    VkBuffer create_buffer(size_t size, VkBufferUsageFlags usage);
+    VkDeviceMemory allocate_memory(size_t size, uint32_t memory_type_index);
+    VkDeviceMemory allocate_dedicated_memory(size_t size, uint32_t memory_type_index, VkImage image, VkBuffer buffer);
+
+    VkImage create_image(int width, int height, int depth, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage);
+    VkImageView create_imageview(VkImage image, VkFormat format);
+};
+
+class VkBlobAllocatorPrivate;
+class NCNN_EXPORT VkBlobAllocator : public VkAllocator
+{
+public:
+    explicit VkBlobAllocator(const VulkanDevice* vkdev, size_t preferred_block_size = 16 * 1024 * 1024); // 16M
+    virtual ~VkBlobAllocator();
+
+public:
+    // release all budgets immediately
+    virtual void clear();
+
+    virtual VkBufferMemory* fastMalloc(size_t size);
+    virtual void fastFree(VkBufferMemory* ptr);
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
+    virtual void fastFree(VkImageMemory* ptr);
+
+private:
+    VkBlobAllocator(const VkBlobAllocator&);
+    VkBlobAllocator& operator=(const VkBlobAllocator&);
+
+private:
+    VkBlobAllocatorPrivate* const d;
+};
+
+class VkWeightAllocatorPrivate;
+class NCNN_EXPORT VkWeightAllocator : public VkAllocator
+{
+public:
+    explicit VkWeightAllocator(const VulkanDevice* vkdev, size_t preferred_block_size = 8 * 1024 * 1024); // 8M
+    virtual ~VkWeightAllocator();
+
+public:
+    // release all blocks immediately
+    virtual void clear();
+
+public:
+    virtual VkBufferMemory* fastMalloc(size_t size);
+    virtual void fastFree(VkBufferMemory* ptr);
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
+    virtual void fastFree(VkImageMemory* ptr);
+
+private:
+    VkWeightAllocator(const VkWeightAllocator&);
+    VkWeightAllocator& operator=(const VkWeightAllocator&);
+
+private:
+    VkWeightAllocatorPrivate* const d;
+};
+
+class VkStagingAllocatorPrivate;
+class NCNN_EXPORT VkStagingAllocator : public VkAllocator
+{
+public:
+    explicit VkStagingAllocator(const VulkanDevice* vkdev);
+    virtual ~VkStagingAllocator();
+
+public:
+    // ratio range 0 ~ 1
+    // default cr = 0.75
+    void set_size_compare_ratio(float scr);
+
+    // release all budgets immediately
+    virtual void clear();
+
+    virtual VkBufferMemory* fastMalloc(size_t size);
+    virtual void fastFree(VkBufferMemory* ptr);
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
+    virtual void fastFree(VkImageMemory* ptr);
+
+private:
+    VkStagingAllocator(const VkStagingAllocator&);
+    VkStagingAllocator& operator=(const VkStagingAllocator&);
+
+private:
+    VkStagingAllocatorPrivate* const d;
+};
+
+class VkWeightStagingAllocatorPrivate;
+class NCNN_EXPORT VkWeightStagingAllocator : public VkAllocator
+{
+public:
+    explicit VkWeightStagingAllocator(const VulkanDevice* vkdev);
+    virtual ~VkWeightStagingAllocator();
+
+public:
+    virtual VkBufferMemory* fastMalloc(size_t size);
+    virtual void fastFree(VkBufferMemory* ptr);
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
+    virtual void fastFree(VkImageMemory* ptr);
+
+private:
+    VkWeightStagingAllocator(const VkWeightStagingAllocator&);
+    VkWeightStagingAllocator& operator=(const VkWeightStagingAllocator&);
+
+private:
+    VkWeightStagingAllocatorPrivate* const d;
+};
+
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 26
+class NCNN_EXPORT VkAndroidHardwareBufferImageAllocator : public VkAllocator
+{
+public:
+    VkAndroidHardwareBufferImageAllocator(const VulkanDevice* _vkdev, AHardwareBuffer* _hb);
+    virtual ~VkAndroidHardwareBufferImageAllocator();
+
+public:
+    virtual VkBufferMemory* fastMalloc(size_t size);
+    virtual void fastFree(VkBufferMemory* ptr);
+    virtual VkImageMemory* fastMalloc(int w, int h, int c, size_t elemsize, int elempack);
+    virtual void fastFree(VkImageMemory* ptr);
+
+private:
+    VkAndroidHardwareBufferImageAllocator(const VkAndroidHardwareBufferImageAllocator&);
+    VkAndroidHardwareBufferImageAllocator& operator=(const VkAndroidHardwareBufferImageAllocator&);
+
+public:
+    int init();
+
+    int width() const;
+    int height() const;
+    uint64_t external_format() const;
+
+public:
+    AHardwareBuffer* hb;
+    AHardwareBuffer_Desc bufferDesc;
+    VkAndroidHardwareBufferFormatPropertiesANDROID bufferFormatProperties;
+    VkAndroidHardwareBufferPropertiesANDROID bufferProperties;
+    VkSamplerYcbcrConversionKHR samplerYcbcrConversion;
+};
+#endif // __ANDROID_API__ >= 26
+#endif // NCNN_PLATFORM_API
+
+#endif // NCNN_VULKAN
+
+} // namespace ncnn
+
+#endif // NCNN_ALLOCATOR_H

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_BENCHMARK_H
+#define NCNN_BENCHMARK_H
+
+#include "layer.h"
+#include "mat.h"
+#include "platform.h"
+
+namespace ncnn {
+
+// get now timestamp in ms
+NCNN_EXPORT double get_current_time();
+
+// sleep milliseconds
+NCNN_EXPORT void sleep(unsigned long long int milliseconds = 1000);
+
+#if NCNN_BENCHMARK
+
+NCNN_EXPORT void benchmark(const Layer* layer, double start, double end);
+NCNN_EXPORT void benchmark(const Layer* layer, const Mat& bottom_blob, Mat& top_blob, double start, double end);
+
+#endif // NCNN_BENCHMARK
+
+} // namespace ncnn
+
+#endif // NCNN_BENCHMARK_H

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_BLOB_H
+#define NCNN_BLOB_H
+
+#include "mat.h"
+#include "platform.h"
+
+namespace ncnn {
+
+class NCNN_EXPORT Blob
+{
+public:
+    // empty
+    Blob();
+
+public:
+#if NCNN_STRING
+    // blob name
+    std::string name;
+#endif // NCNN_STRING
+    // layer index which produce this blob as output
+    int producer;
+    // layer index which need this blob as input
+    int consumer;
+    // shape hint
+    Mat shape;
+};
+
+} // namespace ncnn
+
+#endif // NCNN_BLOB_H

+/* Tencent is pleased to support the open source community by making ncnn available.
+ *
+ * Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed
+ * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+#ifndef NCNN_C_API_H
+#define NCNN_C_API_H
+
+#include "platform.h"
+
+#if NCNN_C_API
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+NCNN_EXPORT const char* ncnn_version(void);
+
+/* allocator api */
+typedef struct __ncnn_allocator_t* ncnn_allocator_t;
+struct NCNN_EXPORT __ncnn_allocator_t
+{
+    void* pthis;
+
+    void* (*fast_malloc)(ncnn_allocator_t allocator, size_t size);
+    void (*fast_free)(ncnn_allocator_t allocator, void* ptr);
+};
+
+NCNN_EXPORT ncnn_allocator_t ncnn_allocator_create_pool_allocator(void);
+NCNN_EXPORT ncnn_allocator_t ncnn_allocator_create_unlocked_pool_allocator(void);
+NCNN_EXPORT void ncnn_allocator_destroy(ncnn_allocator_t allocator);
+
+/* option api */
+typedef struct __ncnn_option_t* ncnn_option_t;
+
+NCNN_EXPORT ncnn_option_t ncnn_option_create(void);
+NCNN_EXPORT void ncnn_option_destroy(ncnn_option_t opt);
+
+NCNN_EXPORT int ncnn_option_get_num_threads(const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_option_set_num_threads(ncnn_option_t opt, int num_threads);
+
+NCNN_EXPORT int ncnn_option_get_use_local_pool_allocator(const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_option_set_use_local_pool_allocator(ncnn_option_t opt, int use_local_pool_allocator);
+
+NCNN_EXPORT void ncnn_option_set_blob_allocator(ncnn_option_t opt, ncnn_allocator_t allocator);
+NCNN_EXPORT void ncnn_option_set_workspace_allocator(ncnn_option_t opt, ncnn_allocator_t allocator);
+
+NCNN_EXPORT int ncnn_option_get_use_vulkan_compute(const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_option_set_use_vulkan_compute(ncnn_option_t opt, int use_vulkan_compute);
+
+/* mat api */
+typedef struct __ncnn_mat_t* ncnn_mat_t;
+
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create(void);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_1d(int w, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_2d(int w, int h, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_3d(int w, int h, int c, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_4d(int w, int h, int d, int c, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_1d(int w, void* data, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_2d(int w, int h, void* data, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_3d(int w, int h, int c, void* data, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_4d(int w, int h, int d, int c, void* data, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_1d_elem(int w, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_2d_elem(int w, int h, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_3d_elem(int w, int h, int c, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_4d_elem(int w, int h, int d, int c, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_1d_elem(int w, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_2d_elem(int w, int h, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_3d_elem(int w, int h, int c, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_create_external_4d_elem(int w, int h, int d, int c, void* data, size_t elemsize, int elempack, ncnn_allocator_t allocator);
+NCNN_EXPORT void ncnn_mat_destroy(ncnn_mat_t mat);
+
+NCNN_EXPORT void ncnn_mat_fill_float(ncnn_mat_t mat, float v);
+
+NCNN_EXPORT ncnn_mat_t ncnn_mat_clone(const ncnn_mat_t mat, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_1d(const ncnn_mat_t mat, int w, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_2d(const ncnn_mat_t mat, int w, int h, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_3d(const ncnn_mat_t mat, int w, int h, int c, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_reshape_4d(const ncnn_mat_t mat, int w, int h, int d, int c, ncnn_allocator_t allocator);
+
+NCNN_EXPORT int ncnn_mat_get_dims(const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_mat_get_w(const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_mat_get_h(const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_mat_get_d(const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_mat_get_c(const ncnn_mat_t mat);
+NCNN_EXPORT size_t ncnn_mat_get_elemsize(const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_mat_get_elempack(const ncnn_mat_t mat);
+NCNN_EXPORT size_t ncnn_mat_get_cstep(const ncnn_mat_t mat);
+NCNN_EXPORT void* ncnn_mat_get_data(const ncnn_mat_t mat);
+
+NCNN_EXPORT void* ncnn_mat_get_channel_data(const ncnn_mat_t mat, int c);
+
+#if NCNN_PIXEL
+
+/* mat pixel api */
+#define NCNN_MAT_PIXEL_RGB       1
+#define NCNN_MAT_PIXEL_BGR       2
+#define NCNN_MAT_PIXEL_GRAY      3
+#define NCNN_MAT_PIXEL_RGBA      4
+#define NCNN_MAT_PIXEL_BGRA      5
+#define NCNN_MAT_PIXEL_X2Y(X, Y) (X | (Y << 16))
+NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels(const unsigned char* pixels, int type, int w, int h, int stride, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_resize(const unsigned char* pixels, int type, int w, int h, int stride, int target_width, int target_height, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_roi(const unsigned char* pixels, int type, int w, int h, int stride, int roix, int roiy, int roiw, int roih, ncnn_allocator_t allocator);
+NCNN_EXPORT ncnn_mat_t ncnn_mat_from_pixels_roi_resize(const unsigned char* pixels, int type, int w, int h, int stride, int roix, int roiy, int roiw, int roih, int target_width, int target_height, ncnn_allocator_t allocator);
+NCNN_EXPORT void ncnn_mat_to_pixels(const ncnn_mat_t mat, unsigned char* pixels, int type, int stride);
+NCNN_EXPORT void ncnn_mat_to_pixels_resize(const ncnn_mat_t mat, unsigned char* pixels, int type, int target_width, int target_height, int target_stride);
+
+#endif /* NCNN_PIXEL */
+
+NCNN_EXPORT void ncnn_mat_substract_mean_normalize(ncnn_mat_t mat, const float* mean_vals, const float* norm_vals);
+
+NCNN_EXPORT void ncnn_convert_packing(const ncnn_mat_t src, ncnn_mat_t* dst, int elempack, const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_flatten(const ncnn_mat_t src, ncnn_mat_t* dst, const ncnn_option_t opt);
+
+/* blob api */
+typedef struct __ncnn_blob_t* ncnn_blob_t;
+
+#if NCNN_STRING
+NCNN_EXPORT const char* ncnn_blob_get_name(const ncnn_blob_t blob);
+#endif /* NCNN_STRING */
+
+NCNN_EXPORT int ncnn_blob_get_producer(const ncnn_blob_t blob);
+NCNN_EXPORT int ncnn_blob_get_consumer(const ncnn_blob_t blob);
+
+NCNN_EXPORT void ncnn_blob_get_shape(const ncnn_blob_t blob, int* dims, int* w, int* h, int* c);
+
+/* paramdict api */
+typedef struct __ncnn_paramdict_t* ncnn_paramdict_t;
+
+NCNN_EXPORT ncnn_paramdict_t ncnn_paramdict_create(void);
+NCNN_EXPORT void ncnn_paramdict_destroy(ncnn_paramdict_t pd);
+
+NCNN_EXPORT int ncnn_paramdict_get_type(const ncnn_paramdict_t pd, int id);
+
+NCNN_EXPORT int ncnn_paramdict_get_int(const ncnn_paramdict_t pd, int id, int def);
+NCNN_EXPORT float ncnn_paramdict_get_float(const ncnn_paramdict_t pd, int id, float def);
+NCNN_EXPORT ncnn_mat_t ncnn_paramdict_get_array(const ncnn_paramdict_t pd, int id, const ncnn_mat_t def);
+
+NCNN_EXPORT void ncnn_paramdict_set_int(ncnn_paramdict_t pd, int id, int i);
+NCNN_EXPORT void ncnn_paramdict_set_float(ncnn_paramdict_t pd, int id, float f);
+NCNN_EXPORT void ncnn_paramdict_set_array(ncnn_paramdict_t pd, int id, const ncnn_mat_t v);
+
+/* datareader api */
+typedef struct __ncnn_datareader_t* ncnn_datareader_t;
+struct NCNN_EXPORT __ncnn_datareader_t
+{
+    void* pthis;
+
+#if NCNN_STRING
+    int (*scan)(ncnn_datareader_t dr, const char* format, void* p);
+#endif /* NCNN_STRING */
+    size_t (*read)(ncnn_datareader_t dr, void* buf, size_t size);
+};
+
+NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create(void);
+#if NCNN_STDIO
+NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create_from_stdio(FILE* fp);
+#endif /* NCNN_STDIO */
+NCNN_EXPORT ncnn_datareader_t ncnn_datareader_create_from_memory(const unsigned char** mem);
+NCNN_EXPORT void ncnn_datareader_destroy(ncnn_datareader_t dr);
+
+/* modelbin api */
+typedef struct __ncnn_modelbin_t* ncnn_modelbin_t;
+struct NCNN_EXPORT __ncnn_modelbin_t
+{
+    void* pthis;
+
+    ncnn_mat_t (*load_1d)(const ncnn_modelbin_t mb, int w, int type);
+    ncnn_mat_t (*load_2d)(const ncnn_modelbin_t mb, int w, int h, int type);
+    ncnn_mat_t (*load_3d)(const ncnn_modelbin_t mb, int w, int h, int c, int type);
+};
+
+NCNN_EXPORT ncnn_modelbin_t ncnn_modelbin_create_from_datareader(const ncnn_datareader_t dr);
+NCNN_EXPORT ncnn_modelbin_t ncnn_modelbin_create_from_mat_array(const ncnn_mat_t* weights, int n);
+NCNN_EXPORT void ncnn_modelbin_destroy(ncnn_modelbin_t mb);
+
+/* layer api */
+typedef struct __ncnn_layer_t* ncnn_layer_t;
+struct NCNN_EXPORT __ncnn_layer_t
+{
+    void* pthis;
+
+    int (*load_param)(ncnn_layer_t layer, const ncnn_paramdict_t pd);
+    int (*load_model)(ncnn_layer_t layer, const ncnn_modelbin_t mb);
+
+    int (*create_pipeline)(ncnn_layer_t layer, const ncnn_option_t opt);
+    int (*destroy_pipeline)(ncnn_layer_t layer, const ncnn_option_t opt);
+
+    int (*forward_1)(const ncnn_layer_t layer, const ncnn_mat_t bottom_blob, ncnn_mat_t* top_blob, const ncnn_option_t opt);
+    int (*forward_n)(const ncnn_layer_t layer, const ncnn_mat_t* bottom_blobs, int n, ncnn_mat_t* top_blobs, int n2, const ncnn_option_t opt);
+
+    int (*forward_inplace_1)(const ncnn_layer_t layer, ncnn_mat_t bottom_top_blob, const ncnn_option_t opt);
+    int (*forward_inplace_n)(const ncnn_layer_t layer, ncnn_mat_t* bottom_top_blobs, int n, const ncnn_option_t opt);
+};
+
+NCNN_EXPORT ncnn_layer_t ncnn_layer_create(void);
+NCNN_EXPORT ncnn_layer_t ncnn_layer_create_by_typeindex(int typeindex);
+#if NCNN_STRING
+NCNN_EXPORT ncnn_layer_t ncnn_layer_create_by_type(const char* type);
+NCNN_EXPORT int ncnn_layer_type_to_index(const char* type);
+#endif /* NCNN_STRING */
+NCNN_EXPORT void ncnn_layer_destroy(ncnn_layer_t layer);
+
+#if NCNN_STRING
+NCNN_EXPORT const char* ncnn_layer_get_name(const ncnn_layer_t layer);
+#endif /* NCNN_STRING */
+
+NCNN_EXPORT int ncnn_layer_get_typeindex(const ncnn_layer_t layer);
+#if NCNN_STRING
+NCNN_EXPORT const char* ncnn_layer_get_type(const ncnn_layer_t layer);
+#endif /* NCNN_STRING */
+
+NCNN_EXPORT int ncnn_layer_get_one_blob_only(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_inplace(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_vulkan(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_packing(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_bf16_storage(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_fp16_storage(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_support_image_storage(const ncnn_layer_t layer);
+
+NCNN_EXPORT void ncnn_layer_set_one_blob_only(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_inplace(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_vulkan(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_packing(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_bf16_storage(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_fp16_storage(ncnn_layer_t layer, int enable);
+NCNN_EXPORT void ncnn_layer_set_support_image_storage(ncnn_layer_t layer, int enable);
+
+NCNN_EXPORT int ncnn_layer_get_bottom_count(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_bottom(const ncnn_layer_t layer, int i);
+NCNN_EXPORT int ncnn_layer_get_top_count(const ncnn_layer_t layer);
+NCNN_EXPORT int ncnn_layer_get_top(const ncnn_layer_t layer, int i);
+
+NCNN_EXPORT void ncnn_blob_get_bottom_shape(const ncnn_layer_t layer, int i, int* dims, int* w, int* h, int* c);
+NCNN_EXPORT void ncnn_blob_get_top_shape(const ncnn_layer_t layer, int i, int* dims, int* w, int* h, int* c);
+
+/* layer factory function */
+typedef ncnn_layer_t (*ncnn_layer_creator_t)(void* userdata);
+typedef void (*ncnn_layer_destroyer_t)(ncnn_layer_t layer, void* userdata);
+
+typedef struct __ncnn_net_custom_layer_factory_t* ncnn_net_custom_layer_factory_t;
+struct __ncnn_net_custom_layer_factory_t
+{
+    ncnn_layer_creator_t creator;
+    ncnn_layer_destroyer_t destroyer;
+    void* userdata;
+    ncnn_net_custom_layer_factory_t next;
+};
+
+/* net api */
+typedef struct __ncnn_net_t* ncnn_net_t;
+struct __ncnn_net_t
+{
+    void* pthis;
+
+    ncnn_net_custom_layer_factory_t custom_layer_factory;
+};
+
+NCNN_EXPORT ncnn_net_t ncnn_net_create(void);
+NCNN_EXPORT void ncnn_net_destroy(ncnn_net_t net);
+
+NCNN_EXPORT ncnn_option_t ncnn_net_get_option(ncnn_net_t net);
+NCNN_EXPORT void ncnn_net_set_option(ncnn_net_t net, ncnn_option_t opt);
+
+#if NCNN_VULKAN
+NCNN_EXPORT void ncnn_net_set_vulkan_device(ncnn_net_t net, int device_index);
+#endif
+
+#if NCNN_STRING
+NCNN_EXPORT void ncnn_net_register_custom_layer_by_type(ncnn_net_t net, const char* type, ncnn_layer_creator_t creator, ncnn_layer_destroyer_t destroyer, void* userdata);
+#endif /* NCNN_STRING */
+NCNN_EXPORT void ncnn_net_register_custom_layer_by_typeindex(ncnn_net_t net, int typeindex, ncnn_layer_creator_t creator, ncnn_layer_destroyer_t destroyer, void* userdata);
+
+#if NCNN_STDIO
+#if NCNN_STRING
+NCNN_EXPORT int ncnn_net_load_param(ncnn_net_t net, const char* path);
+#endif /* NCNN_STRING */
+NCNN_EXPORT int ncnn_net_load_param_bin(ncnn_net_t net, const char* path);
+NCNN_EXPORT int ncnn_net_load_model(ncnn_net_t net, const char* path);
+#endif /* NCNN_STDIO */
+
+#if NCNN_STDIO
+#if NCNN_STRING
+NCNN_EXPORT int ncnn_net_load_param_memory(ncnn_net_t net, const char* mem);
+#endif /* NCNN_STRING */
+#endif /* NCNN_STDIO */
+NCNN_EXPORT int ncnn_net_load_param_bin_memory(ncnn_net_t net, const unsigned char* mem);
+NCNN_EXPORT int ncnn_net_load_model_memory(ncnn_net_t net, const unsigned char* mem);
+
+#if NCNN_STRING
+NCNN_EXPORT int ncnn_net_load_param_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
+#endif /* NCNN_STRING */
+NCNN_EXPORT int ncnn_net_load_param_bin_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
+NCNN_EXPORT int ncnn_net_load_model_datareader(ncnn_net_t net, const ncnn_datareader_t dr);
+
+NCNN_EXPORT void ncnn_net_clear(ncnn_net_t net);
+
+NCNN_EXPORT int ncnn_net_get_input_count(const ncnn_net_t net);
+NCNN_EXPORT int ncnn_net_get_output_count(const ncnn_net_t net);
+#if NCNN_STRING
+NCNN_EXPORT const char* ncnn_net_get_input_name(const ncnn_net_t net, int i);
+NCNN_EXPORT const char* ncnn_net_get_output_name(const ncnn_net_t net, int i);
+#endif /* NCNN_STRING */
+NCNN_EXPORT int ncnn_net_get_input_index(const ncnn_net_t net, int i);
+NCNN_EXPORT int ncnn_net_get_output_index(const ncnn_net_t net, int i);
+
+/* extractor api */
+typedef struct __ncnn_extractor_t* ncnn_extractor_t;
+
+NCNN_EXPORT ncnn_extractor_t ncnn_extractor_create(ncnn_net_t net);
+NCNN_EXPORT void ncnn_extractor_destroy(ncnn_extractor_t ex);
+
+NCNN_EXPORT void ncnn_extractor_set_option(ncnn_extractor_t ex, const ncnn_option_t opt);
+
+#if NCNN_STRING
+NCNN_EXPORT int ncnn_extractor_input(ncnn_extractor_t ex, const char* name, const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_extractor_extract(ncnn_extractor_t ex, const char* name, ncnn_mat_t* mat);
+#endif /* NCNN_STRING */
+NCNN_EXPORT int ncnn_extractor_input_index(ncnn_extractor_t ex, int index, const ncnn_mat_t mat);
+NCNN_EXPORT int ncnn_extractor_extract_index(ncnn_extractor_t ex, int index, ncnn_mat_t* mat);
+
+/* mat process api */
+#define NCNN_BORDER_CONSTANT    0
+#define NCNN_BORDER_REPLICATE   1
+#define NCNN_BORDER_REFLECT     2
+#define NCNN_BORDER_TRANSPARENT -233
+NCNN_EXPORT void ncnn_copy_make_border(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int type, float v, const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_copy_make_border_3d(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int front, int behind, int type, float v, const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_copy_cut_border(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, const ncnn_option_t opt);
+NCNN_EXPORT void ncnn_copy_cut_border_3d(const ncnn_mat_t src, ncnn_mat_t dst, int top, int bottom, int left, int right, int front, int behind, const ncnn_option_t opt);
+
+#if NCNN_PIXEL_DRAWING
+/* mat pixel drawing api*/
+NCNN_EXPORT void ncnn_draw_rectangle_c1(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_rectangle_c2(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_rectangle_c3(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_rectangle_c4(unsigned char* pixels, int w, int h, int rx, int ry, int rw, int rh, unsigned int color, int thickness);
+
+NCNN_EXPORT void ncnn_draw_text_c1(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
+NCNN_EXPORT void ncnn_draw_text_c2(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
+NCNN_EXPORT void ncnn_draw_text_c3(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
+NCNN_EXPORT void ncnn_draw_text_c4(unsigned char* pixels, int w, int h, const char* text, int x, int y, int fontpixelsize, unsigned int color);
+
+NCNN_EXPORT void ncnn_draw_circle_c1(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_circle_c2(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_circle_c3(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_circle_c4(unsigned char* pixels, int w, int h, int cx, int cy, int radius, unsigned int color, int thickness);
+
+NCNN_EXPORT void ncnn_draw_line_c1(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_line_c2(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_line_c3(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
+NCNN_EXPORT void ncnn_draw_line_c4(unsigned char* pixels, int w, int h, int x0, int y0, int x1, int y1, unsigned int color, int thickness);
+#endif /* NCNN_PIXEL_DRAWING */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* NCNN_C_API */
+
+#endif /* NCNN_C_API_H */

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_COMMAND_H
+#define NCNN_COMMAND_H
+
+#include "platform.h"
+
+#if NCNN_VULKAN
+
+#include "mat.h"
+
+namespace ncnn {
+
+class Pipeline;
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 26
+class ImportAndroidHardwareBufferPipeline;
+#endif // __ANDROID_API__ >= 26
+#endif // NCNN_PLATFORM_API
+class VkComputePrivate;
+class NCNN_EXPORT VkCompute
+{
+public:
+    explicit VkCompute(const VulkanDevice* vkdev);
+    virtual ~VkCompute();
+
+public:
+    void record_upload(const Mat& src, VkMat& dst, const Option& opt);
+
+    void record_upload(const Mat& src, VkImageMat& dst, const Option& opt);
+
+    void record_download(const VkMat& src, Mat& dst, const Option& opt);
+
+    void record_download(const VkImageMat& src, Mat& dst, const Option& opt);
+
+    void record_buffer_to_image(const VkMat& src, VkImageMat& dst, const Option& opt);
+
+    void record_image_to_buffer(const VkImageMat& src, VkMat& dst, const Option& opt);
+
+    void record_clone(const Mat& src, VkMat& dst, const Option& opt);
+
+    void record_clone(const Mat& src, VkImageMat& dst, const Option& opt);
+
+    void record_clone(const VkMat& src, Mat& dst, const Option& opt);
+
+    void record_clone(const VkImageMat& src, Mat& dst, const Option& opt);
+
+    void record_clone(const VkMat& src, VkMat& dst, const Option& opt);
+
+    void record_clone(const VkImageMat& src, VkImageMat& dst, const Option& opt);
+
+    void record_clone(const VkMat& src, VkImageMat& dst, const Option& opt);
+
+    void record_clone(const VkImageMat& src, VkMat& dst, const Option& opt);
+
+    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& bindings, const std::vector<vk_constant_type>& constants, const VkMat& dispatcher);
+
+    void record_pipeline(const Pipeline* pipeline, const std::vector<VkImageMat>& bindings, const std::vector<vk_constant_type>& constants, const VkImageMat& dispatcher);
+
+    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const VkMat& dispatcher);
+    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const VkImageMat& dispatcher);
+    void record_pipeline(const Pipeline* pipeline, const std::vector<VkMat>& buffer_bindings, const std::vector<VkImageMat>& image_bindings, const std::vector<vk_constant_type>& constants, const Mat& dispatcher);
+
+#if NCNN_BENCHMARK
+    void record_write_timestamp(uint32_t query);
+#endif // NCNN_BENCHMARK
+
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 26
+    void record_import_android_hardware_buffer(const ImportAndroidHardwareBufferPipeline* pipeline, const VkImageMat& src, const VkMat& dst);
+
+    void record_import_android_hardware_buffer(const ImportAndroidHardwareBufferPipeline* pipeline, const VkImageMat& src, const VkImageMat& dst);
+#endif // __ANDROID_API__ >= 26
+#endif // NCNN_PLATFORM_API
+
+    int submit_and_wait();
+
+    int reset();
+
+#if NCNN_BENCHMARK
+    int create_query_pool(uint32_t query_count);
+
+    int get_query_pool_results(uint32_t first_query, uint32_t query_count, std::vector<uint64_t>& results);
+#endif // NCNN_BENCHMARK
+
+protected:
+    const VulkanDevice* vkdev;
+
+    void barrier_readwrite(const VkMat& binding);
+    void barrier_readwrite(const VkImageMat& binding);
+    void barrier_readonly(const VkImageMat& binding);
+
+private:
+    VkComputePrivate* const d;
+};
+
+class VkTransferPrivate;
+class NCNN_EXPORT VkTransfer
+{
+public:
+    explicit VkTransfer(const VulkanDevice* vkdev);
+    virtual ~VkTransfer();
+
+public:
+    void record_upload(const Mat& src, VkMat& dst, const Option& opt, bool flatten = true);
+
+    void record_upload(const Mat& src, VkImageMat& dst, const Option& opt);
+
+    int submit_and_wait();
+
+protected:
+    const VulkanDevice* vkdev;
+
+private:
+    VkTransferPrivate* const d;
+};
+
+} // namespace ncnn
+
+#endif // NCNN_VULKAN
+
+#endif // NCNN_COMMAND_H

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_CPU_H
+#define NCNN_CPU_H
+
+#include <stddef.h>
+
+#if defined _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+#if defined __ANDROID__ || defined __linux__
+#include <sched.h> // cpu_set_t
+#endif
+
+#include "platform.h"
+
+namespace ncnn {
+
+class NCNN_EXPORT CpuSet
+{
+public:
+    CpuSet();
+    void enable(int cpu);
+    void disable(int cpu);
+    void disable_all();
+    bool is_enabled(int cpu) const;
+    int num_enabled() const;
+
+public:
+#if defined _WIN32
+    ULONG_PTR mask;
+#endif
+#if defined __ANDROID__ || defined __linux__
+    cpu_set_t cpu_set;
+#endif
+#if __APPLE__
+    unsigned int policy;
+#endif
+};
+
+// test optional cpu features
+// edsp = armv7 edsp
+NCNN_EXPORT int cpu_support_arm_edsp();
+// neon = armv7 neon or aarch64 asimd
+NCNN_EXPORT int cpu_support_arm_neon();
+// vfpv4 = armv7 fp16 + fma
+NCNN_EXPORT int cpu_support_arm_vfpv4();
+// asimdhp = aarch64 asimd half precision
+NCNN_EXPORT int cpu_support_arm_asimdhp();
+// cpuid = aarch64 cpuid info
+NCNN_EXPORT int cpu_support_arm_cpuid();
+// asimddp = aarch64 asimd dot product
+NCNN_EXPORT int cpu_support_arm_asimddp();
+// asimdfhm = aarch64 asimd fhm
+NCNN_EXPORT int cpu_support_arm_asimdfhm();
+// bf16 = aarch64 bf16
+NCNN_EXPORT int cpu_support_arm_bf16();
+// i8mm = aarch64 i8mm
+NCNN_EXPORT int cpu_support_arm_i8mm();
+// sve = aarch64 sve
+NCNN_EXPORT int cpu_support_arm_sve();
+// sve2 = aarch64 sve2
+NCNN_EXPORT int cpu_support_arm_sve2();
+// svebf16 = aarch64 svebf16
+NCNN_EXPORT int cpu_support_arm_svebf16();
+// svei8mm = aarch64 svei8mm
+NCNN_EXPORT int cpu_support_arm_svei8mm();
+// svef32mm = aarch64 svef32mm
+NCNN_EXPORT int cpu_support_arm_svef32mm();
+
+// avx = x86 avx
+NCNN_EXPORT int cpu_support_x86_avx();
+// fma = x86 fma
+NCNN_EXPORT int cpu_support_x86_fma();
+// xop = x86 xop
+NCNN_EXPORT int cpu_support_x86_xop();
+// f16c = x86 f16c
+NCNN_EXPORT int cpu_support_x86_f16c();
+// avx2 = x86 avx2 + fma + f16c
+NCNN_EXPORT int cpu_support_x86_avx2();
+// avx_vnni = x86 avx vnni
+NCNN_EXPORT int cpu_support_x86_avx_vnni();
+// avx_vnni_int8 = x86 avx vnni int8
+NCNN_EXPORT int cpu_support_x86_avx_vnni_int8();
+// avx_vnni_int16 = x86 avx vnni int16
+NCNN_EXPORT int cpu_support_x86_avx_vnni_int16();
+// avx_ne_convert = x86 avx ne convert
+NCNN_EXPORT int cpu_support_x86_avx_ne_convert();
+// avx512 = x86 avx512f + avx512cd + avx512bw + avx512dq + avx512vl
+NCNN_EXPORT int cpu_support_x86_avx512();
+// avx512_vnni = x86 avx512 vnni
+NCNN_EXPORT int cpu_support_x86_avx512_vnni();
+// avx512_bf16 = x86 avx512 bf16
+NCNN_EXPORT int cpu_support_x86_avx512_bf16();
+// avx512_fp16 = x86 avx512 fp16
+NCNN_EXPORT int cpu_support_x86_avx512_fp16();
+
+// lsx = loongarch lsx
+NCNN_EXPORT int cpu_support_loongarch_lsx();
+// lasx = loongarch lasx
+NCNN_EXPORT int cpu_support_loongarch_lasx();
+
+// msa = mips mas
+NCNN_EXPORT int cpu_support_mips_msa();
+// mmi = loongson mmi
+NCNN_EXPORT int cpu_support_loongson_mmi();
+
+// v = riscv vector
+NCNN_EXPORT int cpu_support_riscv_v();
+// zfh = riscv half-precision float
+NCNN_EXPORT int cpu_support_riscv_zfh();
+// zvfh = riscv vector half-precision float
+NCNN_EXPORT int cpu_support_riscv_zvfh();
+// xtheadvector = riscv xtheadvector
+NCNN_EXPORT int cpu_support_riscv_xtheadvector();
+// vlenb = riscv vector length in bytes
+NCNN_EXPORT int cpu_riscv_vlenb();
+
+// cpu info
+NCNN_EXPORT int get_cpu_count();
+NCNN_EXPORT int get_little_cpu_count();
+NCNN_EXPORT int get_big_cpu_count();
+
+NCNN_EXPORT int get_physical_cpu_count();
+NCNN_EXPORT int get_physical_little_cpu_count();
+NCNN_EXPORT int get_physical_big_cpu_count();
+
+// cpu l2 varies from 64k to 1M, but l3 can be zero
+NCNN_EXPORT int get_cpu_level2_cache_size();
+NCNN_EXPORT int get_cpu_level3_cache_size();
+
+// bind all threads on little clusters if powersave enabled
+// affects HMP arch cpu like ARM big.LITTLE
+// only implemented on android at the moment
+// switching powersave is expensive and not thread-safe
+// 0 = all cores enabled(default)
+// 1 = only little clusters enabled
+// 2 = only big clusters enabled
+// return 0 if success for setter function
+NCNN_EXPORT int get_cpu_powersave();
+NCNN_EXPORT int set_cpu_powersave(int powersave);
+
+// convenient wrapper
+NCNN_EXPORT const CpuSet& get_cpu_thread_affinity_mask(int powersave);
+
+// set explicit thread affinity
+NCNN_EXPORT int set_cpu_thread_affinity(const CpuSet& thread_affinity_mask);
+
+// runtime thread affinity info
+NCNN_EXPORT int is_current_thread_running_on_a53_a55();
+
+// misc function wrapper for openmp routines
+NCNN_EXPORT int get_omp_num_threads();
+NCNN_EXPORT void set_omp_num_threads(int num_threads);
+
+NCNN_EXPORT int get_omp_dynamic();
+NCNN_EXPORT void set_omp_dynamic(int dynamic);
+
+NCNN_EXPORT int get_omp_thread_num();
+
+NCNN_EXPORT int get_kmp_blocktime();
+NCNN_EXPORT void set_kmp_blocktime(int time_ms);
+
+// need to flush denormals on Intel Chipset.
+// Other architectures such as ARM can be added as needed.
+// 0 = DAZ OFF, FTZ OFF
+// 1 = DAZ ON , FTZ OFF
+// 2 = DAZ OFF, FTZ ON
+// 3 = DAZ ON,  FTZ ON
+NCNN_EXPORT int get_flush_denormals();
+NCNN_EXPORT int set_flush_denormals(int flush_denormals);
+
+} // namespace ncnn
+
+#endif // NCNN_CPU_H

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef NCNN_DATAREADER_H
+#define NCNN_DATAREADER_H
+
+#include "platform.h"
+#if NCNN_STDIO
+#include <stdio.h>
+#endif
+
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 9
+#include <android/asset_manager.h>
+#endif
+#endif // NCNN_PLATFORM_API
+
+namespace ncnn {
+
+// data read wrapper
+class NCNN_EXPORT DataReader
+{
+public:
+    DataReader();
+    virtual ~DataReader();
+
+#if NCNN_STRING
+    // parse plain param text
+    // return 1 if scan success
+    virtual int scan(const char* format, void* p) const;
+#endif // NCNN_STRING
+
+    // read binary param and model data
+    // return bytes read
+    virtual size_t read(void* buf, size_t size) const;
+
+    // get model data reference
+    // return bytes referenced
+    virtual size_t reference(size_t size, const void** buf) const;
+};
+
+#if NCNN_STDIO
+class DataReaderFromStdioPrivate;
+class NCNN_EXPORT DataReaderFromStdio : public DataReader
+{
+public:
+    explicit DataReaderFromStdio(FILE* fp);
+    virtual ~DataReaderFromStdio();
+
+#if NCNN_STRING
+    virtual int scan(const char* format, void* p) const;
+#endif // NCNN_STRING
+    virtual size_t read(void* buf, size_t size) const;
+
+private:
+    DataReaderFromStdio(const DataReaderFromStdio&);
+    DataReaderFromStdio& operator=(const DataReaderFromStdio&);
+
+private:
+    DataReaderFromStdioPrivate* const d;
+};
+#endif // NCNN_STDIO
+
+class DataReaderFromMemoryPrivate;
+class NCNN_EXPORT DataReaderFromMemory : public DataReader
+{
+public:
+    explicit DataReaderFromMemory(const unsigned char*& mem);
+    virtual ~DataReaderFromMemory();
+
+#if NCNN_STRING
+    virtual int scan(const char* format, void* p) const;
+#endif // NCNN_STRING
+    virtual size_t read(void* buf, size_t size) const;
+    virtual size_t reference(size_t size, const void** buf) const;
+
+private:
+    DataReaderFromMemory(const DataReaderFromMemory&);
+    DataReaderFromMemory& operator=(const DataReaderFromMemory&);
+
+private:
+    DataReaderFromMemoryPrivate* const d;
+};
+
+#if NCNN_PLATFORM_API
+#if __ANDROID_API__ >= 9
+class DataReaderFromAndroidAssetPrivate;
+class NCNN_EXPORT DataReaderFromAndroidAsset : public DataReader
+{
+public:
+    explicit DataReaderFromAndroidAsset(AAsset* asset);
+    virtual ~DataReaderFromAndroidAsset();
+
+#if NCNN_STRING
+    virtual int scan(const char* format, void* p) const;
+#endif // NCNN_STRING
+    virtual size_t read(void* buf, size_t size) const;
+
+private:
+    DataReaderFromAndroidAsset(const DataReaderFromAndroidAsset&);
+    DataReaderFromAndroidAsset& operator=(const DataReaderFromAndroidAsset&);
+
+private:
+    DataReaderFromAndroidAssetPrivate* const d;
+};
+#endif // __ANDROID_API__ >= 9
+#endif // NCNN_PLATFORM_API
+
+} // namespace ncnn
+
+#endif // NCNN_DATAREADER_H

+// Tencent is pleased to support the open source community by making ncnn available.
+//
+// Copyright (C) 2025 THL A29 Limited, a Tencent company. All rights reserved.
+//
+// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// https://opensource.org/licenses/BSD-3-Clause
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#include "mat.h"
+
+namespace ncnn {
+
+// count how many blobs are referenced inside expression
+NCNN_EXPORT int count_expression_blobs(const std::string& expr);
+
+// resolve reshape shape from expression and input blobs
+// resolve slice indices(starts, ends) from expression and input blobs
+// see docs/developer-guide/expression.md
+// return 0 if success
+NCNN_EXPORT int eval_list_expression(const std::string& expr, const std::vector<Mat>& blobs, std::vector<int>& outlist);
+
+} // namespace ncnn