VirtualBox

source: vbox/trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h@ 50313

Last change on this file since 50313 was 50313, checked in by vboxsync, 11 years ago

crOpenGL: video recording working
  • Property svn:executable set to *
File size: 9.7 KB
Line 
1/* $Id$ */
2
3/** @file
4 * Blitter API
5 */
6/*
7 * Copyright (C) 2013 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#ifndef ___cr_blitter_h__
18#define ___cr_blitter_h__
19
20#include <iprt/cdefs.h>
21#include <iprt/asm.h>
22#include "cr_spu.h"
23#include "cr_vreg.h"
24
25#ifndef IN_RING0
26# define VBOXBLITTERDECL(_type) DECLEXPORT(_type)
27#else
28# define VBOXBLITTERDECL(_type) RTDECL(_type)
29#endif
30
31RT_C_DECLS_BEGIN
32/* GLSL Cache */
33typedef struct CR_GLSL_CACHE
34{
35 int iGlVersion;
36 GLuint uNoAlpha2DProg;
37 GLuint uNoAlpha2DRectProg;
38 SPUDispatchTable *pDispatch;
39} CR_GLSL_CACHE;
40
41DECLINLINE(void) CrGlslInit(CR_GLSL_CACHE *pCache, SPUDispatchTable *pDispatch)
42{
43 memset(pCache, 0, sizeof (*pCache));
44 pCache->pDispatch = pDispatch;
45}
46
47DECLINLINE(bool) CrGlslIsInited(const CR_GLSL_CACHE *pCache)
48{
49 return !!pCache->pDispatch;
50}
51
52/* clients should set proper context before calling these funcs */
53VBOXBLITTERDECL(bool) CrGlslIsSupported(CR_GLSL_CACHE *pCache);
54VBOXBLITTERDECL(int) CrGlslProgGenAllNoAlpha(CR_GLSL_CACHE *pCache);
55VBOXBLITTERDECL(int) CrGlslProgGenNoAlpha(CR_GLSL_CACHE *pCache, GLenum enmTexTarget);
56VBOXBLITTERDECL(int) CrGlslProgUseGenNoAlpha(CR_GLSL_CACHE *pCache, GLenum enmTexTarget);
57VBOXBLITTERDECL(int) CrGlslProgUseNoAlpha(const CR_GLSL_CACHE *pCache, GLenum enmTexTarget);
58VBOXBLITTERDECL(void) CrGlslProgClear(const CR_GLSL_CACHE *pCache);
59VBOXBLITTERDECL(bool) CrGlslNeedsCleanup(const CR_GLSL_CACHE *pCache);
60VBOXBLITTERDECL(void) CrGlslCleanup(CR_GLSL_CACHE *pCache);
61VBOXBLITTERDECL(void) CrGlslTerm(CR_GLSL_CACHE *pCache);
62
63/* BLITTER */
64typedef struct CR_BLITTER_BUFFER
65{
66 GLuint cbBuffer;
67 GLvoid * pvBuffer;
68} CR_BLITTER_BUFFER, *PCR_BLITTER_BUFFER;
69
70typedef union CR_BLITTER_FLAGS
71{
72 struct
73 {
74 uint32_t Initialized : 1;
75 uint32_t CtxCreated : 1;
76 uint32_t SupportsFBO : 1;
77 uint32_t SupportsPBO : 1;
78 uint32_t CurrentMuralChanged : 1;
79 uint32_t LastWasFBODraw : 1;
80 uint32_t ForceDrawBlit : 1;
81 uint32_t ShadersGloal : 1;
82 uint32_t Entered : 1;
83 uint32_t Reserved : 23;
84 };
85 uint32_t Value;
86} CR_BLITTER_FLAGS, *PCR_BLITTER_FLAGS;
87
88struct CR_BLITTER;
89
90typedef DECLCALLBACK(int) FNCRBLT_BLITTER(struct CR_BLITTER *pBlitter, const VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const RTRECTSIZE *pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags);
91typedef FNCRBLT_BLITTER *PFNCRBLT_BLITTER;
92
93typedef struct CR_BLITTER_SPUITEM
94{
95 int id;
96 GLint visualBits;
97} CR_BLITTER_SPUITEM, *PCR_BLITTER_SPUITEM;
98
99typedef struct CR_BLITTER_CONTEXT
100{
101 CR_BLITTER_SPUITEM Base;
102} CR_BLITTER_CONTEXT, *PCR_BLITTER_CONTEXT;
103
104typedef struct CR_BLITTER_WINDOW
105{
106 CR_BLITTER_SPUITEM Base;
107 GLuint width, height;
108} CR_BLITTER_WINDOW, *PCR_BLITTER_WINDOW;
109
110typedef struct CR_BLITTER_IMG
111{
112 void *pvData;
113 GLuint cbData;
114 GLenum enmFormat;
115 GLuint width, height;
116 GLuint bpp;
117 GLuint pitch;
118} CR_BLITTER_IMG, *PCR_BLITTER_IMG;
119
120typedef struct CR_BLITTER
121{
122 GLuint idFBO;
123 CR_BLITTER_FLAGS Flags;
124 PFNCRBLT_BLITTER pfnBlt;
125 CR_BLITTER_BUFFER Verticies;
126 CR_BLITTER_BUFFER Indicies;
127 RTRECTSIZE CurrentSetSize;
128 CR_BLITTER_WINDOW CurrentMural;
129 CR_BLITTER_CONTEXT CtxInfo;
130 int32_t i32MakeCurrentUserData;
131 SPUDispatchTable *pDispatch;
132 const CR_GLSL_CACHE *pGlslCache;
133 CR_GLSL_CACHE LocalGlslCache;
134} CR_BLITTER, *PCR_BLITTER;
135
136DECLINLINE(GLboolean) CrBltIsInitialized(PCR_BLITTER pBlitter)
137{
138 return !!pBlitter->pDispatch;
139}
140
141VBOXBLITTERDECL(int) CrBltInit(PCR_BLITTER pBlitter, const CR_BLITTER_CONTEXT *pCtxBase, bool fCreateNewCtx, bool fForceDrawBlt, const CR_GLSL_CACHE *pShaders, SPUDispatchTable *pDispatch);
142
143VBOXBLITTERDECL(void) CrBltTerm(PCR_BLITTER pBlitter);
144
145VBOXBLITTERDECL(int) CrBltCleanup(PCR_BLITTER pBlitter);
146
147DECLINLINE(GLboolean) CrBltSupportsTexTex(PCR_BLITTER pBlitter)
148{
149 return pBlitter->Flags.SupportsFBO;
150}
151
152DECLINLINE(GLboolean) CrBltIsEntered(PCR_BLITTER pBlitter)
153{
154 return pBlitter->Flags.Entered;
155}
156
157DECLINLINE(GLint) CrBltGetVisBits(PCR_BLITTER pBlitter)
158{
159 return pBlitter->CtxInfo.Base.visualBits;
160}
161
162
163DECLINLINE(GLboolean) CrBltIsEverEntered(PCR_BLITTER pBlitter)
164{
165 return !!pBlitter->Flags.Initialized;
166}
167
168DECLINLINE(void) CrBltSetMakeCurrentUserData(PCR_BLITTER pBlitter, int32_t i32MakeCurrentUserData)
169{
170 pBlitter->i32MakeCurrentUserData = i32MakeCurrentUserData;
171}
172
173VBOXBLITTERDECL(int) CrBltMuralSetCurrentInfo(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural);
174DECLINLINE(const CR_BLITTER_WINDOW *) CrBltMuralGetCurrentInfo(PCR_BLITTER pBlitter)
175{
176 return &pBlitter->CurrentMural;
177}
178
179VBOXBLITTERDECL(void) CrBltCheckUpdateViewport(PCR_BLITTER pBlitter);
180
181VBOXBLITTERDECL(void) CrBltLeave(PCR_BLITTER pBlitter);
182VBOXBLITTERDECL(int) CrBltEnter(PCR_BLITTER pBlitter);
183VBOXBLITTERDECL(void) CrBltBlitTexMural(PCR_BLITTER pBlitter, bool fBb, const VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags);
184VBOXBLITTERDECL(void) CrBltBlitTexTex(PCR_BLITTER pBlitter, const VBOXVR_TEXTURE *pSrc, const RTRECT *pSrcRect, const VBOXVR_TEXTURE *pDst, const RTRECT *pDstRect, uint32_t cRects, uint32_t fFlags);
185VBOXBLITTERDECL(int) CrBltImgGetTex(PCR_BLITTER pBlitter, const VBOXVR_TEXTURE *pSrc, GLenum enmFormat, CR_BLITTER_IMG *pDst);
186
187VBOXBLITTERDECL(int) CrBltImgGetMural(PCR_BLITTER pBlitter, bool fBb, CR_BLITTER_IMG *pDst);
188VBOXBLITTERDECL(void) CrBltImgFree(PCR_BLITTER pBlitter, CR_BLITTER_IMG *pDst);
189VBOXBLITTERDECL(void) CrBltPresent(PCR_BLITTER pBlitter);
190/* */
191struct CR_TEXDATA;
192
193typedef DECLCALLBACK(void) FNCRTEXDATA_RELEASED(struct CR_TEXDATA *pTexture);
194typedef FNCRTEXDATA_RELEASED *PFNCRTEXDATA_RELEASED;
195
196typedef union CR_TEXDATA_FLAGS
197{
198 struct
199 {
200 uint32_t DataInverted : 1;
201 uint32_t Entered : 1;
202 uint32_t BltEntered : 1;
203 uint32_t Reserved : 29;
204 };
205 uint32_t Value;
206} CR_TEXDATA_FLAGS, *PCR_TEXDATA_FLAGS;
207
208
209typedef struct CR_TEXDATA
210{
211 VBOXVR_TEXTURE Tex;
212 volatile uint32_t cRefs;
213 /* fields specific to texture data download */
214 uint32_t idInvertTex;
215 uint32_t idPBO;
216 CR_TEXDATA_FLAGS Flags;
217 PCR_BLITTER pBlitter;
218 CR_BLITTER_IMG Img;
219 /*dtor*/
220 PFNCRTEXDATA_RELEASED pfnTextureReleased;
221} CR_TEXDATA, *PCR_TEXDATA;
222
223DECLINLINE(void) CrTdInit(PCR_TEXDATA pTex, const VBOXVR_TEXTURE *pVrTex, PCR_BLITTER pBlitter, PFNCRTEXDATA_RELEASED pfnTextureReleased)
224{
225 memset(pTex, 0, sizeof (*pTex));
226 pTex->Tex = *pVrTex;
227 pTex->cRefs = 1;
228 pTex->pBlitter = pBlitter;
229 pTex->pfnTextureReleased = pfnTextureReleased;
230}
231
232DECLINLINE(const VBOXVR_TEXTURE*) CrTdTexGet(const CR_TEXDATA *pTex)
233{
234 return &pTex->Tex;
235}
236
237DECLINLINE(int) CrTdBltEnter(PCR_TEXDATA pTex)
238{
239 if (pTex->Flags.Entered)
240 return VERR_INVALID_STATE;
241 if (!CrBltIsEntered(pTex->pBlitter))
242 {
243 int rc = CrBltEnter(pTex->pBlitter);
244 if (!RT_SUCCESS(rc))
245 {
246 WARN(("CrBltEnter failed rc %d", rc));
247 return rc;
248 }
249 pTex->Flags.BltEntered = 1;
250 }
251 pTex->Flags.Entered = 1;
252 return VINF_SUCCESS;
253}
254
255DECLINLINE(bool) CrTdBltIsEntered(PCR_TEXDATA pTex)
256{
257 return pTex->Flags.Entered;
258}
259
260DECLINLINE(void) CrTdBltLeave(PCR_TEXDATA pTex)
261{
262 if (!pTex->Flags.Entered)
263 {
264 WARN(("invalid Blt Leave"));
265 return;
266 }
267
268 if (pTex->Flags.BltEntered)
269 {
270 CrBltLeave(pTex->pBlitter);
271 pTex->Flags.BltEntered = 0;
272 }
273
274 pTex->Flags.Entered = 0;
275}
276
277/* the CrTdBltXxx calls are done with the entered blitter */
278/* acquire the texture data, returns the cached data in case it is cached.
279 * the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup.
280 * */
281VBOXBLITTERDECL(int) CrTdBltDataAcquire(PCR_TEXDATA pTex, GLenum enmFormat, bool fInverted, const CR_BLITTER_IMG**ppImg);
282/* release the texture data, the data remains cached in the CR_TEXDATA object until it is discarded with CrTdBltDataDiscard or CrTdBltDataCleanup */
283VBOXBLITTERDECL(int) CrTdBltDataRelease(PCR_TEXDATA pTex);
284/* discard the texture data cached with previous CrTdBltDataAcquire.
285 * Must be called wit data released (CrTdBltDataRelease) */
286VBOXBLITTERDECL(int) CrTdBltDataDiscard(PCR_TEXDATA pTex);
287VBOXBLITTERDECL(int) CrTdBltDataDiscardNe(PCR_TEXDATA pTex);
288/* does same as CrTdBltDataDiscard, and in addition cleans up.
289 * this is kind of a texture destructor, which clients should call on texture object destruction, e.g. from the PFNCRTEXDATA_RELEASED callback */
290VBOXBLITTERDECL(int) CrTdBltDataCleanup(PCR_TEXDATA pTex);
291
292VBOXBLITTERDECL(int) CrTdBltDataCleanupNe(PCR_TEXDATA pTex);
293
294DECLINLINE(uint32_t) CrTdAddRef(PCR_TEXDATA pTex)
295{
296 return ASMAtomicIncU32(&pTex->cRefs);
297}
298
299DECLINLINE(uint32_t) CrTdRelease(PCR_TEXDATA pTex)
300{
301 uint32_t cRefs = ASMAtomicDecU32(&pTex->cRefs);
302 if (!cRefs)
303 {
304 if (pTex->pfnTextureReleased)
305 pTex->pfnTextureReleased(pTex);
306 else
307 CrTdBltDataCleanupNe(pTex);
308 }
309
310 return cRefs;
311}
312
313RT_C_DECLS_END
314
315#endif /* #ifndef ___cr_blitter_h__ */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette