[81761] | 1 | /* $Id: DevVGA-SVGA3d-glHlp.cpp 82240 2019-11-27 12:07:12Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * DevVMWare - VMWare SVGA device OpenGL backend
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
| 7 | * Copyright (C) 2013-2019 Oracle Corporation
|
---|
| 8 | *
|
---|
| 9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
| 10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
| 11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
| 12 | * General Public License (GPL) as published by the Free Software
|
---|
| 13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
| 14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
| 15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
| 16 | */
|
---|
| 17 |
|
---|
| 18 |
|
---|
| 19 | /*********************************************************************************************************************************
|
---|
| 20 | * Header Files *
|
---|
| 21 | *********************************************************************************************************************************/
|
---|
| 22 | #ifdef DEBUG_bird
|
---|
| 23 | //# define RTMEM_WRAP_TO_EF_APIS
|
---|
| 24 | #endif
|
---|
| 25 | #define LOG_GROUP LOG_GROUP_DEV_VMSVGA
|
---|
| 26 | #include <VBox/vmm/pdmdev.h>
|
---|
| 27 |
|
---|
| 28 | #include <iprt/assert.h>
|
---|
| 29 | #include <iprt/mem.h>
|
---|
| 30 |
|
---|
| 31 | #include "DevVGA-SVGA.h"
|
---|
| 32 | #include "DevVGA-SVGA3d-internal.h"
|
---|
| 33 |
|
---|
| 34 | /* Parameters for glVertexAttribPointer. */
|
---|
| 35 | typedef struct VertexAttribDesc
|
---|
| 36 | {
|
---|
| 37 | GLint size;
|
---|
| 38 | GLenum type;
|
---|
| 39 | GLboolean normalized;
|
---|
| 40 | GLsizei stride;
|
---|
[82240] | 41 | GLsizei offset;
|
---|
[81761] | 42 | } VertexAttribDesc;
|
---|
| 43 |
|
---|
| 44 | /* Information about a shader program. */
|
---|
| 45 | typedef struct ShaderProgram
|
---|
| 46 | {
|
---|
| 47 | GLuint vertexShader; /* Vertex shader name. */
|
---|
| 48 | GLuint fragmentShader; /* Fragment shader name. */
|
---|
| 49 | GLuint program; /* Shader program name. */
|
---|
| 50 | GLint sSourceTex; /* Location of the texture sampler uniform in the shader. */
|
---|
| 51 | GLint uTexInfo; /* Location of the texture information uniform in the shader. */
|
---|
| 52 | } ShaderProgram;
|
---|
| 53 |
|
---|
| 54 | /* Texture format conversion data.
|
---|
| 55 | * Uses a fragment (pixel) shader to render a source texture in one format
|
---|
| 56 | * to the target texture in another format.
|
---|
| 57 | */
|
---|
| 58 | typedef struct VMSVGA3DFORMATCONVERTER
|
---|
| 59 | {
|
---|
| 60 | PVMSVGA3DSTATE pState;
|
---|
| 61 |
|
---|
| 62 | ShaderProgram programYUY2ToRGB; /* From the YUY2 emulated format to the actual RGB texture. */
|
---|
| 63 | ShaderProgram programYUY2FromRGB; /* From the actual RGB texture to the emulated YUY2 format. */
|
---|
| 64 | ShaderProgram programUYVYToRGB; /* From the UYVY emulated format to the actual RGB texture. */
|
---|
| 65 | ShaderProgram programUYVYFromRGB; /* From the actual RGB texture to the emulated UYVY format. */
|
---|
| 66 |
|
---|
| 67 | GLuint framebuffer; /* Framebuffer object name. */
|
---|
| 68 |
|
---|
[82240] | 69 | GLuint vertexBuffer; /* Vertex attribute buffer. Position + texcoord. */
|
---|
[81761] | 70 | } VMSVGA3DFORMATCONVERTER;
|
---|
| 71 |
|
---|
| 72 | /* Parameters for glVertexAttribPointer. */
|
---|
| 73 | static const VertexAttribDesc aVertexAttribs[] =
|
---|
| 74 | {
|
---|
[82240] | 75 | {2, GL_FLOAT, GL_FALSE, 16, 0 }, /* Position. */
|
---|
| 76 | {2, GL_FLOAT, GL_FALSE, 16, 8 } /* Texcoord. */
|
---|
[81761] | 77 | };
|
---|
| 78 |
|
---|
[82240] | 79 | /* Triangle fan */
|
---|
| 80 | static float const aAttribData[] =
|
---|
[81761] | 81 | {
|
---|
[82240] | 82 | /* positions texcoords */
|
---|
| 83 | -1.0f, -1.0f, 0.0f, 0.0f,
|
---|
| 84 | 1.0f, -1.0f, 1.0f, 0.0f,
|
---|
| 85 | 1.0f, 1.0f, 1.0f, 1.0f,
|
---|
| 86 | -1.0f, 1.0f, 0.0f, 1.0f
|
---|
[81761] | 87 | };
|
---|
| 88 |
|
---|
| 89 | static const GLchar shaderHeaderSource[] =
|
---|
| 90 | {
|
---|
| 91 | " #version 120\n"
|
---|
| 92 | };
|
---|
| 93 |
|
---|
| 94 | static const GLchar vertexShaderSource[] =
|
---|
| 95 | {
|
---|
| 96 | " attribute vec2 attrib0;\n"
|
---|
| 97 | " attribute vec2 attrib1;\n"
|
---|
| 98 | " void main(void)\n"
|
---|
| 99 | " {\n"
|
---|
| 100 | " gl_TexCoord[0].xy = attrib1;\n"
|
---|
| 101 | " gl_Position = vec4(attrib0.x, attrib0.y, 0.0f, 1.0f);\n"
|
---|
| 102 | " }\n"
|
---|
| 103 | };
|
---|
| 104 |
|
---|
| 105 | static const GLchar fetchYUY2Source[] =
|
---|
| 106 | {
|
---|
| 107 | " vec4 fetchYUV(vec4 texColor)\n"
|
---|
| 108 | " {\n"
|
---|
| 109 | " return vec4(texColor.b, texColor.g, texColor.r, texColor.a);\n"
|
---|
| 110 | " }\n"
|
---|
| 111 | };
|
---|
| 112 |
|
---|
| 113 | static const GLchar fetchUYVYSource[] =
|
---|
| 114 | {
|
---|
| 115 | " vec4 fetchYUV(vec4 texColor)\n"
|
---|
| 116 | " {\n"
|
---|
| 117 | " return vec4(texColor.g, texColor.b, texColor.a, texColor.r);\n"
|
---|
| 118 | " }\n"
|
---|
| 119 | };
|
---|
| 120 |
|
---|
| 121 | static const GLchar YUV2RGBShaderSource[] =
|
---|
| 122 | {
|
---|
| 123 | " uniform sampler2D sSourceTex;\n"
|
---|
| 124 | " uniform vec4 uTexInfo;\n"
|
---|
| 125 | " \n"
|
---|
| 126 | " const mat3 yuvCoeffs = mat3\n"
|
---|
| 127 | " (\n"
|
---|
| 128 | " 1.164383f, 0.0f, 1.596027f, // first column \n"
|
---|
| 129 | " 1.164383f, -0.391762f, -0.812968f, // second column\n"
|
---|
| 130 | " 1.164383f, 2.017232f, 0.0f // third column\n"
|
---|
| 131 | " );\n"
|
---|
| 132 | " \n"
|
---|
| 133 | " void main() {\n"
|
---|
| 134 | " // Input texcoords are in [0;1] range for the target.\n"
|
---|
| 135 | " vec2 texCoord = gl_TexCoord[0].xy;\n"
|
---|
| 136 | " // Convert to the target coords in pixels: xPixel = texCoord.x * TextureWidth. \n"
|
---|
| 137 | " float xTargetPixel = texCoord.x * uTexInfo.x;\n"
|
---|
| 138 | " // Source texture is half width, i.e. it contains data in pixels [0; width / 2 - 1].\n"
|
---|
| 139 | " float xSourcePixel = xTargetPixel / 2.0f;\n"
|
---|
| 140 | " // Remainder is about 0.25 for even pixels and about 0.75 for odd pixels.\n"
|
---|
| 141 | " float remainder = fract(xSourcePixel);\n"
|
---|
| 142 | " // Back to the normalized coords: texCoord.x = xPixel / Width.\n"
|
---|
| 143 | " texCoord.x = xSourcePixel * uTexInfo.z;\n"
|
---|
| 144 | " vec4 texColor = texture2D(sSourceTex, texCoord);\n"
|
---|
| 145 | " vec4 y0uy1v = fetchYUV(texColor);\n"
|
---|
| 146 | " // Get y0 for even x coordinates and y1 for odd ones.\n"
|
---|
| 147 | " float y = remainder < 0.5f ? y0uy1v.x : y0uy1v.z;\n"
|
---|
| 148 | " // Make a vector for easier calculation.\n"
|
---|
| 149 | " vec3 yuv = vec3(y, y0uy1v.y, y0uy1v.w);\n"
|
---|
| 150 | " yuv -= vec3(0.0627f, 0.502f, 0.502f);\n"
|
---|
| 151 | " vec3 bgr = yuv * yuvCoeffs;\n"
|
---|
| 152 | " //vec3 bgr;\n"
|
---|
| 153 | " //bgr.r = 1.164383 * yuv.x + 1.596027 * yuv.z;\n"
|
---|
| 154 | " //bgr.g = 1.164383 * yuv.x - 0.391762 * yuv.y - 0.812968 * yuv.z;\n"
|
---|
| 155 | " //bgr.b = 1.164383 * yuv.x + 2.017232 * yuv.y;\n"
|
---|
| 156 | " bgr = clamp(bgr, 0.0f, 1.0f);\n"
|
---|
| 157 | " gl_FragData[0] = vec4(bgr, 1.0f);\n"
|
---|
| 158 | " }\n"
|
---|
| 159 | };
|
---|
| 160 |
|
---|
| 161 | static const GLchar storeYUY2Source[] =
|
---|
| 162 | {
|
---|
| 163 | " vec4 storeYUV(float y0, float u, float y1, float v)\n"
|
---|
| 164 | " {\n"
|
---|
| 165 | " return vec4(y1, u, y0, v);\n"
|
---|
| 166 | " }\n"
|
---|
| 167 | };
|
---|
| 168 |
|
---|
| 169 | static const GLchar storeUYVYSource[] =
|
---|
| 170 | {
|
---|
| 171 | " vec4 storeYUV(float y0, float u, float y1, float v)\n"
|
---|
| 172 | " {\n"
|
---|
| 173 | " return vec4(u, y1, v, y0);\n"
|
---|
| 174 | " }\n"
|
---|
| 175 | };
|
---|
| 176 |
|
---|
| 177 | static const GLchar RGB2YUVShaderSource[] =
|
---|
| 178 | {
|
---|
| 179 | " uniform sampler2D sSourceTex;\n"
|
---|
| 180 | " uniform vec4 uTexInfo;\n"
|
---|
| 181 | " \n"
|
---|
| 182 | " const mat3 bgrCoeffs = mat3\n"
|
---|
| 183 | " (\n"
|
---|
| 184 | " 0.2578f, 0.5039f, 0.0977f, // first column \n"
|
---|
| 185 | " -0.1484f, -0.2891f, 0.4375f, // second column\n"
|
---|
| 186 | " 0.4375f, -0.3672f, -0.0703f // third column\n"
|
---|
| 187 | " );\n"
|
---|
| 188 | " const vec3 yuvShift = vec3(0.0647f, 0.5039f, 0.5039f);\n"
|
---|
| 189 | " \n"
|
---|
| 190 | " void main() {\n"
|
---|
| 191 | " // Input texcoords are in [0;1] range for the target.\n"
|
---|
| 192 | " vec2 texCoordDst = gl_TexCoord[0].xy;\n"
|
---|
| 193 | " // Convert to the target coords in pixels: xPixel = TexCoord.x * TextureWidth.\n"
|
---|
| 194 | " float xTargetPixel = texCoordDst.x * uTexInfo.x;\n"
|
---|
| 195 | " vec4 bgraOutputPixel;\n"
|
---|
| 196 | " if (xTargetPixel < uTexInfo.x / 2.0f)\n"
|
---|
| 197 | " {\n"
|
---|
| 198 | " // Target texture is half width, i.e. it contains data in pixels [0; width / 2 - 1].\n"
|
---|
| 199 | " // Compute the source texture coords for the pixels which will be used to compute the target pixel.\n"
|
---|
| 200 | " vec2 texCoordSrc = texCoordDst;\n"
|
---|
| 201 | " texCoordSrc.x *= 2.0f;\n"
|
---|
| 202 | " // Even pixel. Fetch two BGRA source pixels.\n"
|
---|
| 203 | " vec4 texColor0 = texture2D(sSourceTex, texCoordSrc);\n"
|
---|
| 204 | " // Advance one pixel (+ 1/Width)\n"
|
---|
| 205 | " texCoordSrc.x += uTexInfo.z;\n"
|
---|
| 206 | " vec4 texColor1 = texture2D(sSourceTex, texCoordSrc);\n"
|
---|
[81770] | 207 | " vec3 yuv0 = texColor0.rgb * bgrCoeffs;\n"
|
---|
[81761] | 208 | " yuv0 += yuvShift;\n"
|
---|
[81770] | 209 | " vec3 yuv1 = texColor1.rgb * bgrCoeffs;\n"
|
---|
[81761] | 210 | " yuv1 += yuvShift;\n"
|
---|
| 211 | " float y0 = yuv0.r;\n"
|
---|
| 212 | " float u = (yuv0.g + yuv1.g) / 2.0f;\n"
|
---|
| 213 | " float y1 = yuv1.r;\n"
|
---|
| 214 | " float v = (yuv0.b + yuv1.b) / 2.0f;\n"
|
---|
| 215 | " bgraOutputPixel = storeYUV(y0, u, y1, v);\n"
|
---|
| 216 | " }\n"
|
---|
| 217 | " else\n"
|
---|
| 218 | " {\n"
|
---|
| 219 | " // [width / 2; width - 1] pixels are not used. Set to something.\n"
|
---|
| 220 | " bgraOutputPixel = vec4(0.0f, 0.0f, 0.0f, 0.0f);\n"
|
---|
| 221 | " }\n"
|
---|
| 222 | " bgraOutputPixel = clamp(bgraOutputPixel, 0.0f, 1.0f);\n"
|
---|
| 223 | " gl_FragData[0] = bgraOutputPixel;\n"
|
---|
| 224 | " }\n"
|
---|
| 225 | };
|
---|
| 226 |
|
---|
| 227 | #define GL_CHECK_ERROR() do { \
|
---|
| 228 | VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext); \
|
---|
| 229 | if (pContext->lastError != GL_NO_ERROR) \
|
---|
| 230 | LogRelMax(10, ("VMSVGA: %s (%d): GL error 0x%x\n", __FUNCTION__, __LINE__, pContext->lastError)); \
|
---|
| 231 | } while (0)
|
---|
| 232 |
|
---|
| 233 | /* Compile shaders and link a shader program. */
|
---|
| 234 | static void createShaderProgram(PVMSVGA3DSTATE pState,
|
---|
| 235 | ShaderProgram *pProgram,
|
---|
| 236 | int cVertexSources, const GLchar **apszVertexSources,
|
---|
| 237 | int cFragmentSources, const GLchar **apszFragmentSources)
|
---|
| 238 | {
|
---|
| 239 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 240 |
|
---|
| 241 | /* Everything is done on the shared context. The pState and pContext are for GL_CHECK_ERROR macro. */
|
---|
| 242 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 243 |
|
---|
| 244 | int success;
|
---|
| 245 | char szInfoLog[1024];
|
---|
| 246 |
|
---|
| 247 | /*
|
---|
| 248 | * VERTEX shader.
|
---|
| 249 | */
|
---|
| 250 | pProgram->vertexShader = pState->ext.glCreateShader(GL_VERTEX_SHADER);
|
---|
| 251 | GL_CHECK_ERROR();
|
---|
| 252 |
|
---|
| 253 | pState->ext.glShaderSource(pProgram->vertexShader, cVertexSources, apszVertexSources, NULL);
|
---|
| 254 | GL_CHECK_ERROR();
|
---|
| 255 |
|
---|
| 256 | pState->ext.glCompileShader(pProgram->vertexShader);
|
---|
| 257 | GL_CHECK_ERROR();
|
---|
| 258 |
|
---|
| 259 | pState->ext.glGetShaderiv(pProgram->vertexShader, GL_COMPILE_STATUS, &success);
|
---|
| 260 | GL_CHECK_ERROR();
|
---|
| 261 | if (!success)
|
---|
| 262 | {
|
---|
| 263 | pState->ext.glGetShaderInfoLog(pProgram->vertexShader, sizeof(szInfoLog), NULL, szInfoLog);
|
---|
| 264 | GL_CHECK_ERROR();
|
---|
| 265 | LogRelMax(10, ("VMSVGA: Vertex shader compilation error:\n%s\n", szInfoLog));
|
---|
| 266 | };
|
---|
| 267 |
|
---|
| 268 | /*
|
---|
| 269 | * FRAGMENT shader.
|
---|
| 270 | */
|
---|
| 271 | pProgram->fragmentShader = pState->ext.glCreateShader(GL_FRAGMENT_SHADER);
|
---|
| 272 | GL_CHECK_ERROR();
|
---|
| 273 |
|
---|
| 274 | pState->ext.glShaderSource(pProgram->fragmentShader, cFragmentSources, apszFragmentSources, NULL);
|
---|
| 275 | GL_CHECK_ERROR();
|
---|
| 276 |
|
---|
| 277 | pState->ext.glCompileShader(pProgram->fragmentShader);
|
---|
| 278 | GL_CHECK_ERROR();
|
---|
| 279 |
|
---|
| 280 | pState->ext.glGetShaderiv(pProgram->fragmentShader, GL_COMPILE_STATUS, &success);
|
---|
| 281 | GL_CHECK_ERROR();
|
---|
| 282 | if (!success)
|
---|
| 283 | {
|
---|
| 284 | pState->ext.glGetShaderInfoLog(pProgram->fragmentShader, sizeof(szInfoLog), NULL, szInfoLog);
|
---|
| 285 | GL_CHECK_ERROR();
|
---|
| 286 | LogRelMax(10, ("VMSVGA: Fragment shader compilation error:\n%s\n", szInfoLog));
|
---|
| 287 | };
|
---|
| 288 |
|
---|
| 289 | /*
|
---|
| 290 | * Program
|
---|
| 291 | */
|
---|
| 292 | pProgram->program = pState->ext.glCreateProgram();
|
---|
| 293 | GL_CHECK_ERROR();
|
---|
| 294 |
|
---|
| 295 | pState->ext.glAttachShader(pProgram->program, pProgram->vertexShader);
|
---|
| 296 | GL_CHECK_ERROR();
|
---|
| 297 |
|
---|
| 298 | pState->ext.glAttachShader(pProgram->program, pProgram->fragmentShader);
|
---|
| 299 | GL_CHECK_ERROR();
|
---|
| 300 |
|
---|
| 301 | pState->ext.glLinkProgram(pProgram->program);
|
---|
| 302 | GL_CHECK_ERROR();
|
---|
| 303 |
|
---|
| 304 | pState->ext.glGetProgramiv(pProgram->program, GL_LINK_STATUS, &success);
|
---|
| 305 | if(!success)
|
---|
| 306 | {
|
---|
| 307 | pState->ext.glGetProgramInfoLog(pProgram->program, sizeof(szInfoLog), NULL, szInfoLog);
|
---|
| 308 | GL_CHECK_ERROR();
|
---|
| 309 | LogRelMax(10, ("VMSVGA: Shader program link error:\n%s\n", szInfoLog));
|
---|
| 310 | }
|
---|
| 311 |
|
---|
| 312 | pProgram->sSourceTex = pState->ext.glGetUniformLocation(pProgram->program, "sSourceTex");
|
---|
| 313 | GL_CHECK_ERROR();
|
---|
| 314 |
|
---|
| 315 | pProgram->uTexInfo = pState->ext.glGetUniformLocation(pProgram->program, "uTexInfo");
|
---|
| 316 | GL_CHECK_ERROR();
|
---|
| 317 | }
|
---|
| 318 |
|
---|
| 319 | /* Delete a shader program and associated shaders. */
|
---|
| 320 | static void deleteShaderProgram(PVMSVGA3DSTATE pState,
|
---|
| 321 | ShaderProgram *pProgram)
|
---|
| 322 | {
|
---|
| 323 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 324 |
|
---|
| 325 | /* Everything is done on the shared context. The pState and pContext are for GL_CHECK_ERROR macro. */
|
---|
| 326 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 327 |
|
---|
| 328 | if (pProgram->program)
|
---|
| 329 | {
|
---|
| 330 | if (pProgram->vertexShader)
|
---|
| 331 | {
|
---|
| 332 | pState->ext.glDetachShader(pProgram->program, pProgram->vertexShader);
|
---|
| 333 | GL_CHECK_ERROR();
|
---|
| 334 |
|
---|
| 335 | pState->ext.glDeleteShader(pProgram->vertexShader);
|
---|
| 336 | GL_CHECK_ERROR();
|
---|
| 337 | }
|
---|
| 338 |
|
---|
| 339 | if (pProgram->fragmentShader)
|
---|
| 340 | {
|
---|
| 341 | pState->ext.glDetachShader(pProgram->program, pProgram->fragmentShader);
|
---|
| 342 | GL_CHECK_ERROR();
|
---|
| 343 |
|
---|
| 344 | pState->ext.glDeleteShader(pProgram->fragmentShader);
|
---|
| 345 | GL_CHECK_ERROR();
|
---|
| 346 | }
|
---|
| 347 |
|
---|
| 348 | pState->ext.glDeleteProgram(pProgram->program);
|
---|
| 349 | GL_CHECK_ERROR();
|
---|
| 350 | }
|
---|
| 351 |
|
---|
| 352 | RT_ZERO(*pProgram);
|
---|
| 353 | }
|
---|
| 354 |
|
---|
| 355 | /* Initialize the format conversion. Allocate and create necessary resources. */
|
---|
| 356 | static void formatConversionInit(PVMSVGA3DSTATE pState)
|
---|
| 357 | {
|
---|
| 358 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 359 |
|
---|
| 360 | PVMSVGA3DFORMATCONVERTER pConv = pState->pConv;
|
---|
| 361 | AssertReturnVoid(pConv);
|
---|
| 362 |
|
---|
| 363 | /* The pState and pContext variables are for GL_CHECK_ERROR macro. */
|
---|
| 364 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 365 |
|
---|
| 366 | pConv->pState = pState;
|
---|
| 367 |
|
---|
| 368 | /*
|
---|
| 369 | * Shader programs.
|
---|
| 370 | */
|
---|
| 371 | static const GLchar *apszVertexShaderSources[] =
|
---|
| 372 | {
|
---|
| 373 | shaderHeaderSource,
|
---|
| 374 | vertexShaderSource
|
---|
| 375 | };
|
---|
| 376 |
|
---|
| 377 | static const GLchar * apszYUY2ToRGBSources[] =
|
---|
| 378 | {
|
---|
| 379 | shaderHeaderSource,
|
---|
| 380 | fetchYUY2Source,
|
---|
| 381 | YUV2RGBShaderSource
|
---|
| 382 | };
|
---|
| 383 |
|
---|
| 384 | static const GLchar *apszUYVYToRGBSources[] =
|
---|
| 385 | {
|
---|
| 386 | shaderHeaderSource,
|
---|
| 387 | fetchUYVYSource,
|
---|
| 388 | YUV2RGBShaderSource
|
---|
| 389 | };
|
---|
| 390 |
|
---|
| 391 | static const GLchar *apszYUY2FromRGBSources[] =
|
---|
| 392 | {
|
---|
| 393 | shaderHeaderSource,
|
---|
| 394 | storeYUY2Source,
|
---|
| 395 | RGB2YUVShaderSource
|
---|
| 396 | };
|
---|
| 397 |
|
---|
| 398 | static const GLchar *apszUYVYFromRGBSources[] =
|
---|
| 399 | {
|
---|
| 400 | shaderHeaderSource,
|
---|
| 401 | storeUYVYSource,
|
---|
| 402 | RGB2YUVShaderSource
|
---|
| 403 | };
|
---|
| 404 |
|
---|
| 405 | createShaderProgram(pState, &pConv->programYUY2ToRGB,
|
---|
| 406 | RT_ELEMENTS(apszVertexShaderSources), apszVertexShaderSources,
|
---|
| 407 | RT_ELEMENTS(apszYUY2ToRGBSources), apszYUY2ToRGBSources);
|
---|
| 408 |
|
---|
| 409 | createShaderProgram(pState, &pConv->programUYVYToRGB,
|
---|
| 410 | RT_ELEMENTS(apszVertexShaderSources), apszVertexShaderSources,
|
---|
| 411 | RT_ELEMENTS(apszUYVYToRGBSources), apszUYVYToRGBSources);
|
---|
| 412 |
|
---|
| 413 | createShaderProgram(pState, &pConv->programYUY2FromRGB,
|
---|
| 414 | RT_ELEMENTS(apszVertexShaderSources), apszVertexShaderSources,
|
---|
| 415 | RT_ELEMENTS(apszYUY2FromRGBSources), apszYUY2FromRGBSources);
|
---|
| 416 |
|
---|
| 417 | createShaderProgram(pState, &pConv->programUYVYFromRGB,
|
---|
| 418 | RT_ELEMENTS(apszVertexShaderSources), apszVertexShaderSources,
|
---|
| 419 | RT_ELEMENTS(apszUYVYFromRGBSources), apszUYVYFromRGBSources);
|
---|
| 420 |
|
---|
| 421 | /*
|
---|
| 422 | * Create a framebuffer object which is used for rendering to a texture.
|
---|
| 423 | */
|
---|
| 424 | pState->ext.glGenFramebuffers(1, &pConv->framebuffer);
|
---|
| 425 | GL_CHECK_ERROR();
|
---|
| 426 |
|
---|
[82240] | 427 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, pConv->framebuffer);
|
---|
[81761] | 428 | GL_CHECK_ERROR();
|
---|
| 429 |
|
---|
[82240] | 430 | static GLenum aDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
|
---|
| 431 | pState->ext.glDrawBuffers(RT_ELEMENTS(aDrawBuffers), aDrawBuffers);
|
---|
| 432 | GL_CHECK_ERROR();
|
---|
[81761] | 433 |
|
---|
[82240] | 434 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
---|
| 435 | GL_CHECK_ERROR();
|
---|
[81761] | 436 |
|
---|
[82240] | 437 | /*
|
---|
| 438 | * Vertex attribute array.
|
---|
| 439 | */
|
---|
| 440 | pState->ext.glGenBuffers(1, &pConv->vertexBuffer);
|
---|
| 441 | GL_CHECK_ERROR();
|
---|
[81761] | 442 |
|
---|
[82240] | 443 | pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pConv->vertexBuffer);
|
---|
| 444 | GL_CHECK_ERROR();
|
---|
[81761] | 445 |
|
---|
[82240] | 446 | pState->ext.glBufferData(GL_ARRAY_BUFFER, sizeof(aAttribData), aAttribData, GL_STATIC_DRAW);
|
---|
| 447 | GL_CHECK_ERROR();
|
---|
[81761] | 448 |
|
---|
| 449 | pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
---|
| 450 | GL_CHECK_ERROR();
|
---|
| 451 | }
|
---|
| 452 |
|
---|
| 453 | /* Delete everything. */
|
---|
| 454 | static void formatConversionDestroy(PVMSVGA3DSTATE pState)
|
---|
| 455 | {
|
---|
| 456 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 457 |
|
---|
| 458 | PVMSVGA3DFORMATCONVERTER pConv = pState->pConv;
|
---|
| 459 | AssertReturnVoid(pConv);
|
---|
| 460 |
|
---|
| 461 | /* The pState and pContext variables are for GL_CHECK_ERROR macro. */
|
---|
| 462 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 463 |
|
---|
| 464 | if (pConv->framebuffer != 0)
|
---|
| 465 | {
|
---|
| 466 | /* The code keeps nothing attached. */
|
---|
| 467 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, pConv->framebuffer);
|
---|
| 468 | GL_CHECK_ERROR();
|
---|
| 469 |
|
---|
| 470 | GLint texture = -1;
|
---|
| 471 | pState->ext.glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
|
---|
| 472 | GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &texture);
|
---|
| 473 | GL_CHECK_ERROR();
|
---|
| 474 | AssertMsg(texture == 0, ("texture %d\n", texture));
|
---|
| 475 |
|
---|
| 476 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
---|
| 477 | GL_CHECK_ERROR();
|
---|
| 478 |
|
---|
| 479 | pState->ext.glDeleteFramebuffers(1, &pConv->framebuffer);
|
---|
| 480 | GL_CHECK_ERROR();
|
---|
| 481 |
|
---|
| 482 | pConv->framebuffer = 0;
|
---|
| 483 | }
|
---|
| 484 |
|
---|
| 485 | deleteShaderProgram(pState, &pConv->programUYVYFromRGB);
|
---|
| 486 | deleteShaderProgram(pState, &pConv->programYUY2FromRGB);
|
---|
| 487 | deleteShaderProgram(pState, &pConv->programUYVYToRGB);
|
---|
| 488 | deleteShaderProgram(pState, &pConv->programYUY2ToRGB);
|
---|
| 489 |
|
---|
[82240] | 490 | if (pConv->vertexBuffer)
|
---|
[81761] | 491 | {
|
---|
[82240] | 492 | pState->ext.glDeleteBuffers(1, &pConv->vertexBuffer);
|
---|
[81761] | 493 | GL_CHECK_ERROR();
|
---|
[82240] | 494 |
|
---|
| 495 | pConv->vertexBuffer = 0;
|
---|
[81761] | 496 | }
|
---|
| 497 |
|
---|
| 498 | pConv->pState = 0;
|
---|
| 499 | }
|
---|
| 500 |
|
---|
| 501 | /* Make use of a shader program for the current context and initialize the program uniforms. */
|
---|
| 502 | static void setShaderProgram(PVMSVGA3DSTATE pState,
|
---|
| 503 | ShaderProgram *pProgram,
|
---|
| 504 | uint32_t cWidth,
|
---|
| 505 | uint32_t cHeight)
|
---|
| 506 | {
|
---|
| 507 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 508 |
|
---|
| 509 | /* Everything is done on the shared context. The pState and pContext are for GL_CHECK_ERROR macro. */
|
---|
| 510 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 511 |
|
---|
| 512 | pState->ext.glUseProgram(pProgram->program);
|
---|
| 513 | GL_CHECK_ERROR();
|
---|
| 514 |
|
---|
| 515 | pState->ext.glUniform1i(pProgram->sSourceTex, 0);
|
---|
| 516 | GL_CHECK_ERROR();
|
---|
| 517 |
|
---|
| 518 | float aTextureInfo[4];
|
---|
| 519 | aTextureInfo[0] = (float)cWidth;
|
---|
| 520 | aTextureInfo[1] = (float)cHeight;
|
---|
| 521 | aTextureInfo[2] = 1.0f / (float)cWidth; /* Pixel width in texture coords. */
|
---|
| 522 | aTextureInfo[3] = 1.0f / (float)cHeight; /* Pixel height in texture coords. */
|
---|
| 523 |
|
---|
| 524 | pState->ext.glUniform4fv(pProgram->uTexInfo, 1, aTextureInfo);
|
---|
| 525 | GL_CHECK_ERROR();
|
---|
| 526 | }
|
---|
| 527 |
|
---|
| 528 | /* Attach the texture which must be used as the render target
|
---|
| 529 | * to the GL_DRAW_FRAMEBUFFER as GL_COLOR_ATTACHMENT0.
|
---|
| 530 | */
|
---|
| 531 | static void setRenderTarget(PVMSVGA3DSTATE pState,
|
---|
| 532 | GLuint texture,
|
---|
| 533 | uint32_t iMipmap)
|
---|
| 534 | {
|
---|
| 535 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 536 |
|
---|
| 537 | PVMSVGA3DFORMATCONVERTER pConv = pState->pConv;
|
---|
| 538 | AssertReturnVoid(pConv);
|
---|
| 539 |
|
---|
| 540 | /* Everything is done on the shared context. The pState and pContext are for GL_CHECK_ERROR macro. */
|
---|
| 541 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 542 |
|
---|
| 543 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, pConv->framebuffer);
|
---|
| 544 | GL_CHECK_ERROR();
|
---|
| 545 |
|
---|
| 546 | glBindTexture(GL_TEXTURE_2D, texture);
|
---|
| 547 | GL_CHECK_ERROR();
|
---|
| 548 |
|
---|
| 549 | pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, iMipmap);
|
---|
| 550 | GL_CHECK_ERROR();
|
---|
| 551 |
|
---|
| 552 | glBindTexture(GL_TEXTURE_2D, 0);
|
---|
| 553 | GL_CHECK_ERROR();
|
---|
| 554 |
|
---|
| 555 | Assert(pState->ext.glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
|
---|
| 556 | }
|
---|
| 557 |
|
---|
| 558 | /* Undo what setRenderTarget did. */
|
---|
| 559 | static void unsetRenderTarget(PVMSVGA3DSTATE pState,
|
---|
| 560 | GLuint texture)
|
---|
| 561 | {
|
---|
| 562 | AssertReturnVoid(pState->idActiveContext == VMSVGA3D_SHARED_CTX_ID);
|
---|
| 563 |
|
---|
| 564 | /* Everything is done on the shared context. The pState and pContext are for GL_CHECK_ERROR macro. */
|
---|
| 565 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 566 |
|
---|
[82240] | 567 | RT_NOREF(texture);
|
---|
[81761] | 568 |
|
---|
| 569 | pState->ext.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
---|
| 570 | GL_CHECK_ERROR();
|
---|
| 571 |
|
---|
| 572 | pState->ext.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
---|
| 573 | GL_CHECK_ERROR();
|
---|
| 574 | }
|
---|
| 575 |
|
---|
| 576 | /** Convert one texture to another.
|
---|
| 577 | *
|
---|
| 578 | * @param pState The backend.
|
---|
| 579 | * @param pCurrentContext The current context, which must be restored before returning.
|
---|
| 580 | * @param pSurface The surface which needs conversion.
|
---|
| 581 | * @param iMipmap The mipmap level which needs to be converted.
|
---|
| 582 | * @param fToRGB True for conversion from the intermediate texture emulated format
|
---|
| 583 | * to the RGB format of the actual texture.
|
---|
| 584 | * False for conversion from the actual RGB texture to the intermediate texture.
|
---|
| 585 | */
|
---|
| 586 | static void doRender(PVMSVGA3DSTATE pState,
|
---|
| 587 | PVMSVGA3DCONTEXT pCurrentContext,
|
---|
| 588 | PVMSVGA3DSURFACE pSurface,
|
---|
| 589 | uint32_t iMipmap,
|
---|
| 590 | bool fToRGB)
|
---|
| 591 | {
|
---|
[82240] | 592 | if (!fToRGB)
|
---|
| 593 | {
|
---|
| 594 | /** @todo Disable readback transfers for now. They cause crash in glDrawArrays with Mesa 19.2 after
|
---|
| 595 | * a previously converted texture is deleted and another texture is being converted.
|
---|
| 596 | * Such transfer are useless anyway for the emulated YUV formats and the guest should not need them usually.
|
---|
| 597 | */
|
---|
| 598 | return;
|
---|
| 599 | }
|
---|
| 600 |
|
---|
| 601 | LogFunc(("formatConversion: idActiveContext %u, pConv %p, sid=%u, oglid=%u, oglidEmul=%u, mm=%u, %s\n",
|
---|
| 602 | pState->idActiveContext, pState->pConv, pSurface->id, pSurface->oglId.texture, pSurface->idEmulated, iMipmap, fToRGB ? "ToRGB" : "FromRGB"));
|
---|
| 603 |
|
---|
[81761] | 604 | PVMSVGA3DFORMATCONVERTER pConv = pState->pConv;
|
---|
| 605 | AssertReturnVoid(pConv);
|
---|
| 606 |
|
---|
| 607 | ShaderProgram *pProgram = NULL;
|
---|
| 608 | GLuint sourceTexture = 0;
|
---|
| 609 | GLuint targetTexture = 0;
|
---|
| 610 | if (fToRGB)
|
---|
| 611 | {
|
---|
| 612 | if (pSurface->format == SVGA3D_YUY2)
|
---|
| 613 | {
|
---|
| 614 | pProgram = &pConv->programYUY2ToRGB;
|
---|
| 615 | }
|
---|
| 616 | else if (pSurface->format == SVGA3D_UYVY)
|
---|
| 617 | {
|
---|
| 618 | pProgram = &pConv->programUYVYToRGB;
|
---|
| 619 | }
|
---|
| 620 | sourceTexture = pSurface->idEmulated;
|
---|
| 621 | targetTexture = pSurface->oglId.texture;
|
---|
| 622 | }
|
---|
| 623 | else
|
---|
| 624 | {
|
---|
| 625 | if (pSurface->format == SVGA3D_YUY2)
|
---|
| 626 | {
|
---|
| 627 | pProgram = &pConv->programYUY2FromRGB;
|
---|
| 628 | }
|
---|
| 629 | else if (pSurface->format == SVGA3D_UYVY)
|
---|
| 630 | {
|
---|
| 631 | pProgram = &pConv->programUYVYFromRGB;
|
---|
| 632 | }
|
---|
| 633 | sourceTexture = pSurface->oglId.texture;
|
---|
| 634 | targetTexture = pSurface->idEmulated;
|
---|
| 635 | }
|
---|
| 636 |
|
---|
| 637 | AssertReturnVoid(pProgram);
|
---|
| 638 |
|
---|
[82095] | 639 | PVMSVGA3DMIPMAPLEVEL pMipmapLevel;
|
---|
| 640 | int rc = vmsvga3dMipmapLevel(pSurface, 0, iMipmap, &pMipmapLevel);
|
---|
| 641 | AssertRCReturnVoid(rc);
|
---|
[81761] | 642 |
|
---|
[82095] | 643 | uint32_t const cWidth = pMipmapLevel->mipmapSize.width;
|
---|
| 644 | uint32_t const cHeight = pMipmapLevel->mipmapSize.height;
|
---|
| 645 |
|
---|
[81761] | 646 | /* Use the shared context, where all textures are created. */
|
---|
| 647 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 648 | VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
|
---|
| 649 |
|
---|
| 650 | setShaderProgram(pState, pProgram, cWidth, cHeight);
|
---|
| 651 |
|
---|
| 652 | setRenderTarget(pState, targetTexture, iMipmap);
|
---|
| 653 |
|
---|
| 654 | glViewport(0, 0, cWidth, cHeight);
|
---|
| 655 | GL_CHECK_ERROR();
|
---|
| 656 |
|
---|
| 657 | glDisable(GL_DEPTH_TEST);
|
---|
| 658 | GL_CHECK_ERROR();
|
---|
| 659 |
|
---|
| 660 | pState->ext.glActiveTexture(GL_TEXTURE0);
|
---|
| 661 | GL_CHECK_ERROR();
|
---|
| 662 |
|
---|
| 663 | glBindTexture(GL_TEXTURE_2D, sourceTexture);
|
---|
| 664 | GL_CHECK_ERROR();
|
---|
| 665 |
|
---|
| 666 | /* Make sure to set the simplest filter. Otherwise the conversion will not work. */
|
---|
| 667 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
---|
| 668 | GL_CHECK_ERROR();
|
---|
| 669 |
|
---|
| 670 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
---|
| 671 | GL_CHECK_ERROR();
|
---|
| 672 |
|
---|
[82240] | 673 | pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pConv->vertexBuffer);
|
---|
| 674 | GL_CHECK_ERROR();
|
---|
| 675 |
|
---|
| 676 | GLuint index;
|
---|
| 677 | for (index = 0; index < RT_ELEMENTS(aVertexAttribs); ++index)
|
---|
| 678 | {
|
---|
| 679 | pState->ext.glEnableVertexAttribArray(index);
|
---|
| 680 | GL_CHECK_ERROR();
|
---|
| 681 |
|
---|
| 682 | pState->ext.glVertexAttribPointer(index, aVertexAttribs[index].size, aVertexAttribs[index].type,
|
---|
| 683 | aVertexAttribs[index].normalized, aVertexAttribs[index].stride,
|
---|
| 684 | (const GLvoid *)(uintptr_t)aVertexAttribs[index].offset);
|
---|
| 685 | GL_CHECK_ERROR();
|
---|
| 686 | }
|
---|
| 687 |
|
---|
[81761] | 688 | glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
---|
| 689 | GL_CHECK_ERROR();
|
---|
| 690 |
|
---|
[82240] | 691 | pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
|
---|
| 692 | GL_CHECK_ERROR();
|
---|
| 693 |
|
---|
[81761] | 694 | glBindTexture(GL_TEXTURE_2D, 0);
|
---|
| 695 | GL_CHECK_ERROR();
|
---|
| 696 |
|
---|
[82096] | 697 | unsetRenderTarget(pState, targetTexture);
|
---|
[81761] | 698 |
|
---|
| 699 | pState->ext.glUseProgram(0);
|
---|
| 700 | GL_CHECK_ERROR();
|
---|
| 701 |
|
---|
[82240] | 702 | for (index = 0; index < RT_ELEMENTS(aVertexAttribs); ++index)
|
---|
[81761] | 703 | {
|
---|
| 704 | pState->ext.glDisableVertexAttribArray(index);
|
---|
| 705 | GL_CHECK_ERROR();
|
---|
| 706 | }
|
---|
| 707 |
|
---|
| 708 | /* Restore the current context. */
|
---|
| 709 | VMSVGA3D_SET_CURRENT_CONTEXT(pState, pCurrentContext);
|
---|
| 710 | }
|
---|
| 711 |
|
---|
| 712 | void FormatConvUpdateTexture(PVMSVGA3DSTATE pState,
|
---|
| 713 | PVMSVGA3DCONTEXT pCurrentContext,
|
---|
| 714 | PVMSVGA3DSURFACE pSurface,
|
---|
| 715 | uint32_t iMipmap)
|
---|
| 716 | {
|
---|
| 717 | doRender(pState, pCurrentContext, pSurface, iMipmap, true);
|
---|
| 718 | }
|
---|
| 719 |
|
---|
| 720 | void FormatConvReadTexture(PVMSVGA3DSTATE pState,
|
---|
| 721 | PVMSVGA3DCONTEXT pCurrentContext,
|
---|
| 722 | PVMSVGA3DSURFACE pSurface,
|
---|
| 723 | uint32_t iMipmap)
|
---|
| 724 | {
|
---|
| 725 | doRender(pState, pCurrentContext, pSurface, iMipmap, false);
|
---|
| 726 | }
|
---|
| 727 |
|
---|
| 728 | void vmsvga3dOnSharedContextDefine(PVMSVGA3DSTATE pState)
|
---|
| 729 | {
|
---|
| 730 | /* Use the shared context, where all textures are created. */
|
---|
| 731 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 732 | VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
|
---|
| 733 |
|
---|
| 734 | /*
|
---|
| 735 | * Format conversion.
|
---|
| 736 | */
|
---|
| 737 | Assert(pState->pConv == NULL);
|
---|
| 738 |
|
---|
| 739 | pState->pConv = (VMSVGA3DFORMATCONVERTER *)RTMemAllocZ(sizeof(VMSVGA3DFORMATCONVERTER));
|
---|
| 740 | AssertReturnVoid(pState->pConv);
|
---|
| 741 |
|
---|
| 742 | formatConversionInit(pState);
|
---|
| 743 | }
|
---|
| 744 |
|
---|
| 745 | void vmsvga3dOnSharedContextDestroy(PVMSVGA3DSTATE pState)
|
---|
| 746 | {
|
---|
| 747 | /* Use the shared context, where all textures are created. */
|
---|
| 748 | PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
|
---|
| 749 | VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
|
---|
| 750 |
|
---|
| 751 | if (pState->pConv)
|
---|
| 752 | {
|
---|
| 753 | formatConversionDestroy(pState);
|
---|
| 754 |
|
---|
| 755 | RTMemFree(pState->pConv);
|
---|
| 756 | pState->pConv = NULL;
|
---|
| 757 | }
|
---|
| 758 | }
|
---|