flaky test on CI: shader fails to compile on macos14/x86_64

QWARN  : tst_QScreenCaptureBackend::setScreen_selectsScreen_whenCalledWithWidgetsScreen() No MTLDevice

QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
BFAIL  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() 'qBlue(rgb) >= 200' returned FALSE. ()
   Loc: [/Users/qt/work/qt/qtmultimedia/tests/auto/integration/qscreencapturebackend/tst_qscreencapturebackend.cpp(555)]
SKIP   : tst_QScreenCaptureBackend::removeScreenWhileCapture() TODO: find a reliable way to emulate it
   Loc: [/Users/qt/work/qt/qtmultimedia/tests/auto/integration/qscreencapturebackend/tst_qscreencapturebackend.cpp(576)]
PASS   : tst_QScreenCaptureBackend::cleanupTestCase()
Totals: 2 passed, 0 failed, 2 skipped, 4 blacklisted, 5977ms
********* Finished testing of tst_QScreenCaptureBackend *********
qt-testrunner.py     INFO: Test process exited with code: -6
qt-testrunner.py     INFO: Parsed XML file /Users/qt/work/testresults/tst_qscreencapturebackend-1752676138758.xml in 0.002 seconds
qt-testrunner.py     INFO: Found 8 passes and 0 failures
qt-testrunner.py  WARNING: CRASH detected, re-running the whole executable
qt-testrunner.py     INFO: Will re-run the full test executable
qt-testrunner.py    DEBUG: Running test command line: ['/Users/qt/work/qt/qtmultimedia_standalone_tests/tests/auto/integration/qscreencapturebackend/tst_qscreencapturebackend', '-o', '/Users/qt/work/testresults/tst_qscreencapturebackend-1752676144909.xml,xml', '-o', '/Users/qt/work/testresults/tst_qscreencapturebackend-1752676144909.junit.xml,junitxml', '-o', '/Users/qt/work/testresults/tst_qscreencapturebackend-1752676144909.txt,txt', '-o', '-,txt']
********* Start testing of tst_QScreenCaptureBackend *********
Config: Using QtTest library 6.10.0, Qt 6.10.0 (x86_64-little_endian-lp64 shared (dynamic) release build; by Apple LLVM 16.0.0 (clang-1600.0.26.3)), macos 14.0
QINFO  : tst_QScreenCaptureBackend::initTestCase() qt.multimedia.ffmpeg: Using Qt multimedia with FFmpeg version 7.1.1 LGPL version 2.1 or later
PASS   : tst_QScreenCaptureBackend::initTestCase()
BPASS  : tst_QScreenCaptureBackend::setActive_startsAndStopsCapture()
QWARN  : tst_QScreenCaptureBackend::setScreen_selectsScreen_whenCalledWithWidgetsScreen() No MTLDevice
BPASS  : tst_QScreenCaptureBackend::setScreen_selectsScreen_whenCalledWithWidgetsScreen()
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
QWARN  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault() Failed to link shader program: 
BPASS  : tst_QScreenCaptureBackend::constructor_selectsPrimaryScreenAsDefault()
SKIP   : tst_QScreenCaptureBackend::setScreen_selectsSecondaryScreen_whenCalledWithSecondaryScreen() 2 or more screens required
   Loc: [/Users/qt/work/qt/qtmultimedia/tests/auto/integration/qscreencapturebackend/tst_qscreencapturebackend.cpp(438)]
QINFO  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() qt.multimedia.ffmpeg.encoder: Recording new media with muxer MP4 (MPEG-4 Part 14) to "/Users/qt/Movies/video_0002.mp4" with format: QMediaFormat::MPEG4, QMediaFormat::AudioCodec::AAC, QMediaFormat::VideoCodec::H265
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/Users/qt/Movies/video_0002.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2mp41
    date            : 2025-07-16T14:29:06
    encoder         : Lavf61.7.100
  Duration: 00:00:02.07, start: 0.000000, bitrate: 355 kb/s
  Stream #0:0[0x1](und): Video: hevc (Main 10) (hvc1 / 0x31637668), yuv420p10le(tv, bt709/unknown/bt709), 1920x1080 [SAR 1:1 DAR 16:9], 351 kb/s, 8.23 fps, 60 tbr, 60k tbn (default)
      Metadata:
        handler_name    : VideoHandler
        vendor_id       : [0][0][0][0]
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}
QWARN  : tst_QScreenCaptureBackend::capture_capturesToFile_whenConnectedToMediaRecorder() Failed to compile shader: 
Source was:
#version 120
struct buf
{
    mat4 matrix;
    mat4 colorMatrix;
    float opacity;
    float width;
    float masteringWhite;
    float maxLum;
    int redOrAlphaIndex;
    int plane1Format;
    int plane2Format;
    int plane3Format;
};
uniform buf ubuf;
uniform sampler2D plane1Texture;
uniform sampler2D plane2Texture;
varying vec2 texCoord;
float convert_RG8_to_R16(vec2 rg)
{
    return ((rg.x * 255.0) + ((rg.y * 255.0) * 256.0)) / 65535.0;
}
float get_R16_from_packed_RGBA8_texture(sampler2D planeTexture, vec2 texCoord_1, float frameWidth, int rhiScale)
{
    float sampleWidth = float(rhiScale) / frameWidth;
    float subSampleWidth = sampleWidth / 2.0;
    float colIndex = floor(texCoord_1.x / sampleWidth);
    float middleSampleX = (colIndex * sampleWidth) + (0.5 * sampleWidth);
    vec4 rgba = texture2D(planeTexture, vec2(middleSampleX, texCoord_1.y));
    vec2 param = rgba.xy;
    float r0 = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float r1 = convert_RG8_to_R16(param_1);
    float x0 = middleSampleX - (0.5 * subSampleWidth);
    float x1 = middleSampleX + (0.5 * subSampleWidth);
    bool _131 = texCoord_1.x >= x0;
    bool _138;
    if (_131)
    {
        _138 = texCoord_1.x < x1;
    }
    else
    {
        _138 = _131;
    }
    if (_138)
    {
        return mix(r0, r1, (texCoord_1.x - x0) / subSampleWidth);
    }
    else
    {
        if (texCoord_1.x >= x1)
        {
            float rightSampleX = middleSampleX + sampleWidth;
            if (rightSampleX < 1.0)
            {
                vec4 rightSample = texture2D(planeTexture, vec2(rightSampleX, texCoord_1.y));
                vec2 param_2 = rightSample.xy;
                return mix(r1, convert_RG8_to_R16(param_2), (texCoord_1.x - x1) / subSampleWidth);
            }
            else
            {
                return r1;
            }
        }
        else
        {
            float leftSampleX = middleSampleX - sampleWidth;
            if (leftSampleX >= 0.0)
            {
                vec4 leftSample = texture2D(planeTexture, vec2(leftSampleX, texCoord_1.y));
                vec2 param_3 = leftSample.zw;
                return mix(r0, convert_RG8_to_R16(param_3), (x0 - texCoord_1.x) / subSampleWidth);
            }
            else
            {
                return r0;
            }
        }
    }
}
float getR16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat, int xScale)
{
    if (rhiTextureFormat == 5)
    {
        return texture2D(planeTexture, texCoord_1).x;
    }
    if (rhiTextureFormat == 4)
    {
        vec2 param = texture2D(planeTexture, texCoord_1).xy;
        return convert_RG8_to_R16(param);
    }
    if (rhiTextureFormat == 1)
    {
        vec2 param_1 = texCoord_1;
        float param_2 = ubuf.width;
        int param_3 = xScale * 2;
        return get_R16_from_packed_RGBA8_texture(planeTexture, param_1, param_2, param_3);
    }
    return 0.0;
}
vec2 convert_RGBA8_to_RG16(vec4 rgba)
{
    vec2 param = rgba.xy;
    float r = convert_RG8_to_R16(param);
    vec2 param_1 = rgba.zw;
    float g = convert_RG8_to_R16(param_1);
    return vec2(r, g);
}
vec2 getRG16(sampler2D planeTexture, vec2 texCoord_1, int rhiTextureFormat)
{
    if (rhiTextureFormat == 6)
    {
        return texture2D(planeTexture, texCoord_1).xy;
    }
    if (rhiTextureFormat == 1)
    {
        vec4 param = texture2D(planeTexture, texCoord_1);
        return convert_RGBA8_to_RG16(param);
    }
    return vec2(0.0);
}
void main()
{
    vec2 param = texCoord;
    int param_1 = ubuf.plane1Format;
    int param_2 = 1;
    float Y = getR16(plane1Texture, param, param_1, param_2);
    vec2 param_3 = texCoord;
    int param_4 = ubuf.plane2Format;
    vec2 UV = getRG16(plane2Texture, param_3, param_4);
    vec4 color = vec4(Y, UV.x, UV.y, 1.0);
    gl_FragData[0] = (ubuf.colorMatrix * color) * ubuf.opacity;
    gl_FragData[0] = clamp(gl_FragData[0], vec4(0.0), vec4(1.0));
}