VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoTools.h

Last change on this file was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.2 KB
Line 
1/* $Id: VBoxVideoTools.h 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * VBox Video tooling
4 */
5
6/*
7 * Copyright (C) 2012-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#ifndef GA_INCLUDED_SRC_WINNT_Graphics_Video_common_VBoxVideoTools_h
29#define GA_INCLUDED_SRC_WINNT_Graphics_Video_common_VBoxVideoTools_h
30#ifndef RT_WITHOUT_PRAGMA_ONCE
31# pragma once
32#endif
33
34#include <iprt/cdefs.h>
35#include <iprt/assert.h>
36
37typedef struct VBOXVTLIST_ENTRY
38{
39 struct VBOXVTLIST_ENTRY *pNext;
40} VBOXVTLIST_ENTRY, *PVBOXVTLIST_ENTRY;
41
42typedef struct VBOXVTLIST
43{
44 PVBOXVTLIST_ENTRY pFirst;
45 PVBOXVTLIST_ENTRY pLast;
46} VBOXVTLIST, *PVBOXVTLIST;
47
48DECLINLINE(bool) vboxVtListIsEmpty(PVBOXVTLIST pList)
49{
50 return !pList->pFirst;
51}
52
53DECLINLINE(void) vboxVtListInit(PVBOXVTLIST pList)
54{
55 pList->pFirst = pList->pLast = NULL;
56}
57
58DECLINLINE(void) vboxVtListPut(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY pFirst, PVBOXVTLIST_ENTRY pLast)
59{
60 Assert(pFirst);
61 Assert(pLast);
62 pLast->pNext = NULL;
63 if (pList->pLast)
64 {
65 Assert(pList->pFirst);
66 pList->pLast->pNext = pFirst;
67 pList->pLast = pLast;
68 }
69 else
70 {
71 Assert(!pList->pFirst);
72 pList->pFirst = pFirst;
73 pList->pLast = pLast;
74 }
75}
76
77#define vboxVtListPutTail vboxVtListPut
78
79DECLINLINE(void) vboxVtListPutHead(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY pFirst, PVBOXVTLIST_ENTRY pLast)
80{
81 Assert(pFirst);
82 Assert(pLast);
83 pLast->pNext = pList->pFirst;
84 if (!pList->pLast)
85 {
86 Assert(!pList->pFirst);
87 pList->pLast = pLast;
88 }
89 else
90 {
91 Assert(pList->pFirst);
92 }
93 pList->pFirst = pFirst;
94}
95
96DECLINLINE(void) vboxVtListPutEntryHead(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY pEntry)
97{
98 vboxVtListPutHead(pList, pEntry, pEntry);
99}
100
101DECLINLINE(void) vboxVtListPutEntryTail(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY pEntry)
102{
103 vboxVtListPutTail(pList, pEntry, pEntry);
104}
105
106DECLINLINE(void) vboxVtListCat(PVBOXVTLIST pList1, PVBOXVTLIST pList2)
107{
108 vboxVtListPut(pList1, pList2->pFirst, pList2->pLast);
109 pList2->pFirst = pList2->pLast = NULL;
110}
111
112DECLINLINE(void) vboxVtListDetach(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY *ppFirst, PVBOXVTLIST_ENTRY *ppLast)
113{
114 *ppFirst = pList->pFirst;
115 if (ppLast)
116 *ppLast = pList->pLast;
117 pList->pFirst = NULL;
118 pList->pLast = NULL;
119}
120
121DECLINLINE(void) vboxVtListDetach2List(PVBOXVTLIST pList, PVBOXVTLIST pDstList)
122{
123 vboxVtListDetach(pList, &pDstList->pFirst, &pDstList->pLast);
124}
125
126DECLINLINE(void) vboxVtListDetachEntries(PVBOXVTLIST pList, PVBOXVTLIST_ENTRY pBeforeDetach, PVBOXVTLIST_ENTRY pLast2Detach)
127{
128 if (pBeforeDetach)
129 {
130 pBeforeDetach->pNext = pLast2Detach->pNext;
131 if (!pBeforeDetach->pNext)
132 pList->pLast = pBeforeDetach;
133 }
134 else
135 {
136 pList->pFirst = pLast2Detach->pNext;
137 if (!pList->pFirst)
138 pList->pLast = NULL;
139 }
140 pLast2Detach->pNext = NULL;
141}
142
143DECLINLINE(void) vboxWddmRectUnite(RECT *pR, const RECT *pR2Unite)
144{
145 pR->left = RT_MIN(pR->left, pR2Unite->left);
146 pR->top = RT_MIN(pR->top, pR2Unite->top);
147 pR->right = RT_MAX(pR->right, pR2Unite->right);
148 pR->bottom = RT_MAX(pR->bottom, pR2Unite->bottom);
149}
150
151DECLINLINE(bool) vboxWddmRectIntersection(const RECT *a, const RECT *b, RECT *rect)
152{
153 Assert(a);
154 Assert(b);
155 Assert(rect);
156 rect->left = RT_MAX(a->left, b->left);
157 rect->right = RT_MIN(a->right, b->right);
158 rect->top = RT_MAX(a->top, b->top);
159 rect->bottom = RT_MIN(a->bottom, b->bottom);
160 return (rect->right>rect->left) && (rect->bottom>rect->top);
161}
162
163DECLINLINE(bool) vboxWddmRectIsEqual(const RECT *pRect1, const RECT *pRect2)
164{
165 Assert(pRect1);
166 Assert(pRect2);
167 if (pRect1->left != pRect2->left)
168 return false;
169 if (pRect1->top != pRect2->top)
170 return false;
171 if (pRect1->right != pRect2->right)
172 return false;
173 if (pRect1->bottom != pRect2->bottom)
174 return false;
175 return true;
176}
177
178DECLINLINE(bool) vboxWddmRectIsCoveres(const RECT *pRect, const RECT *pCovered)
179{
180 Assert(pRect);
181 Assert(pCovered);
182 if (pRect->left > pCovered->left)
183 return false;
184 if (pRect->top > pCovered->top)
185 return false;
186 if (pRect->right < pCovered->right)
187 return false;
188 if (pRect->bottom < pCovered->bottom)
189 return false;
190 return true;
191}
192
193DECLINLINE(bool) vboxWddmRectIsEmpty(const RECT * pRect)
194{
195 return pRect->left == pRect->right-1 && pRect->top == pRect->bottom-1;
196}
197
198DECLINLINE(bool) vboxWddmRectIsIntersect(const RECT * pRect1, const RECT * pRect2)
199{
200 return !((pRect1->left < pRect2->left && pRect1->right <= pRect2->left)
201 || (pRect2->left < pRect1->left && pRect2->right <= pRect1->left)
202 || (pRect1->top < pRect2->top && pRect1->bottom <= pRect2->top)
203 || (pRect2->top < pRect1->top && pRect2->bottom <= pRect1->top));
204}
205
206DECLINLINE(void) vboxWddmRectUnited(RECT * pDst, const RECT * pRect1, const RECT * pRect2)
207{
208 pDst->left = RT_MIN(pRect1->left, pRect2->left);
209 pDst->top = RT_MIN(pRect1->top, pRect2->top);
210 pDst->right = RT_MAX(pRect1->right, pRect2->right);
211 pDst->bottom = RT_MAX(pRect1->bottom, pRect2->bottom);
212}
213
214DECLINLINE(void) vboxWddmRectTranslate(RECT * pRect, int x, int y)
215{
216 pRect->left += x;
217 pRect->top += y;
218 pRect->right += x;
219 pRect->bottom += y;
220}
221
222DECLINLINE(void) vboxWddmRectMove(RECT * pRect, int x, int y)
223{
224 LONG w = pRect->right - pRect->left;
225 LONG h = pRect->bottom - pRect->top;
226 pRect->left = x;
227 pRect->top = y;
228 pRect->right = w + x;
229 pRect->bottom = h + y;
230}
231
232DECLINLINE(void) vboxWddmRectTranslated(RECT *pDst, const RECT * pRect, int x, int y)
233{
234 *pDst = *pRect;
235 vboxWddmRectTranslate(pDst, x, y);
236}
237
238DECLINLINE(void) vboxWddmRectMoved(RECT *pDst, const RECT * pRect, int x, int y)
239{
240 *pDst = *pRect;
241 vboxWddmRectMove(pDst, x, y);
242}
243
244typedef struct VBOXPOINT3D
245{
246 UINT x;
247 UINT y;
248 UINT z;
249} VBOXPOINT3D, *PVBOXPOINT3D;
250
251typedef struct VBOXBOX3D
252{
253 UINT Left;
254 UINT Top;
255 UINT Right;
256 UINT Bottom;
257 UINT Front;
258 UINT Back;
259} VBOXBOX3D, *PVBOXBOX3D;
260
261DECLINLINE(void) vboxWddmBoxTranslate(VBOXBOX3D * pBox, int x, int y, int z)
262{
263 pBox->Left += x;
264 pBox->Top += y;
265 pBox->Right += x;
266 pBox->Bottom += y;
267 pBox->Front += z;
268 pBox->Back += z;
269}
270
271DECLINLINE(void) vboxWddmBoxMove(VBOXBOX3D * pBox, int x, int y, int z)
272{
273 LONG w = pBox->Right - pBox->Left;
274 LONG h = pBox->Bottom - pBox->Top;
275 LONG d = pBox->Back - pBox->Front;
276 pBox->Left = x;
277 pBox->Top = y;
278 pBox->Right = w + x;
279 pBox->Bottom = h + y;
280 pBox->Front = z;
281 pBox->Back = d + z;
282}
283
284#define VBOXWDDM_BOXDIV_U(_v, _d, _nz) do { \
285 UINT tmp = (_v) / (_d); \
286 if (!tmp && (_v) && (_nz)) \
287 (_v) = 1; \
288 else \
289 (_v) = tmp; \
290 } while (0)
291
292DECLINLINE(void) vboxWddmBoxDivide(VBOXBOX3D * pBox, int div, bool fDontReachZero)
293{
294 VBOXWDDM_BOXDIV_U(pBox->Left, div, fDontReachZero);
295 VBOXWDDM_BOXDIV_U(pBox->Top, div, fDontReachZero);
296 VBOXWDDM_BOXDIV_U(pBox->Right, div, fDontReachZero);
297 VBOXWDDM_BOXDIV_U(pBox->Bottom, div, fDontReachZero);
298 VBOXWDDM_BOXDIV_U(pBox->Front, div, fDontReachZero);
299 VBOXWDDM_BOXDIV_U(pBox->Back, div, fDontReachZero);
300}
301
302DECLINLINE(void) vboxWddmPoint3DDivide(VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
303{
304 VBOXWDDM_BOXDIV_U(pPoint->x, div, fDontReachZero);
305 VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
306 VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
307}
308
309DECLINLINE(void) vboxWddmBoxTranslated(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
310{
311 *pDst = *pBox;
312 vboxWddmBoxTranslate(pDst, x, y, z);
313}
314
315DECLINLINE(void) vboxWddmBoxMoved(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
316{
317 *pDst = *pBox;
318 vboxWddmBoxMove(pDst, x, y, z);
319}
320
321DECLINLINE(void) vboxWddmBoxDivided(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int div, bool fDontReachZero)
322{
323 *pDst = *pBox;
324 vboxWddmBoxDivide(pDst, div, fDontReachZero);
325}
326
327DECLINLINE(void) vboxWddmPoint3DDivided(VBOXPOINT3D * pDst, const VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
328{
329 *pDst = *pPoint;
330 vboxWddmPoint3DDivide(pDst, div, fDontReachZero);
331}
332
333/* the dirty rect info is valid */
334#define VBOXWDDM_DIRTYREGION_F_VALID 0x00000001
335#define VBOXWDDM_DIRTYREGION_F_RECT_VALID 0x00000002
336
337typedef struct VBOXWDDM_DIRTYREGION
338{
339 uint32_t fFlags; /* <-- see VBOXWDDM_DIRTYREGION_F_xxx flags above */
340 RECT Rect;
341} VBOXWDDM_DIRTYREGION, *PVBOXWDDM_DIRTYREGION;
342
343DECLINLINE(void) vboxWddmDirtyRegionAddRect(PVBOXWDDM_DIRTYREGION pInfo, const RECT *pRect)
344{
345 if (!(pInfo->fFlags & VBOXWDDM_DIRTYREGION_F_VALID))
346 {
347 pInfo->fFlags = VBOXWDDM_DIRTYREGION_F_VALID;
348 if (pRect)
349 {
350 pInfo->fFlags |= VBOXWDDM_DIRTYREGION_F_RECT_VALID;
351 pInfo->Rect = *pRect;
352 }
353 }
354 else if (!!(pInfo->fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID))
355 {
356 if (pRect)
357 vboxWddmRectUnite(&pInfo->Rect, pRect);
358 else
359 pInfo->fFlags &= ~VBOXWDDM_DIRTYREGION_F_RECT_VALID;
360 }
361}
362
363DECLINLINE(void) vboxWddmDirtyRegionUnite(PVBOXWDDM_DIRTYREGION pInfo, const VBOXWDDM_DIRTYREGION *pInfo2)
364{
365 if (pInfo2->fFlags & VBOXWDDM_DIRTYREGION_F_VALID)
366 {
367 if (pInfo2->fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID)
368 vboxWddmDirtyRegionAddRect(pInfo, &pInfo2->Rect);
369 else
370 vboxWddmDirtyRegionAddRect(pInfo, NULL);
371 }
372}
373
374DECLINLINE(void) vboxWddmDirtyRegionClear(PVBOXWDDM_DIRTYREGION pInfo)
375{
376 pInfo->fFlags = 0;
377}
378
379#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_common_VBoxVideoTools_h */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use