VirtualBox

source: vbox/trunk/src/VBox/Main/src-all/DisplayUtils.cpp@ 59083

Last change on this file since 59083 was 54792, checked in by vboxsync, 10 years ago

DisplayUtils: use >= when check sSSMDisplayVerX in readSavedGuestScreenInfo() (addition to r98984).

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.1 KB
Line 
1/* $Id: DisplayUtils.cpp 54792 2015-03-16 16:04:24Z vboxsync $ */
2/** @file
3 * Implementation of IDisplay helpers.
4 */
5
6/*
7 * Copyright (C) 2010-2012 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#include <DisplayUtils.h>
19
20#include <iprt/log.h>
21#include <VBox/err.h>
22#include <VBox/vmm/ssm.h>
23#include <VBox/VBoxVideo.h>
24
25int readSavedDisplayScreenshot(const Utf8Str &strStateFilePath, uint32_t u32Type, uint8_t **ppu8Data, uint32_t *pcbData,
26 uint32_t *pu32Width, uint32_t *pu32Height)
27{
28 LogFlowFunc(("u32Type = %d [%s]\n", u32Type, strStateFilePath.c_str()));
29
30 /* @todo cache read data */
31 if (strStateFilePath.isEmpty())
32 {
33 /* No saved state data. */
34 return VERR_NOT_SUPPORTED;
35 }
36
37 uint8_t *pu8Data = NULL;
38 uint32_t cbData = 0;
39 uint32_t u32Width = 0;
40 uint32_t u32Height = 0;
41
42 PSSMHANDLE pSSM;
43 int vrc = SSMR3Open(strStateFilePath.c_str(), 0 /*fFlags*/, &pSSM);
44 if (RT_SUCCESS(vrc))
45 {
46 uint32_t uVersion;
47 vrc = SSMR3Seek(pSSM, "DisplayScreenshot", 1100 /*iInstance*/, &uVersion);
48 if (RT_SUCCESS(vrc))
49 {
50 if (uVersion == sSSMDisplayScreenshotVer)
51 {
52 uint32_t cBlocks;
53 vrc = SSMR3GetU32(pSSM, &cBlocks);
54 AssertRCReturn(vrc, vrc);
55
56 for (uint32_t i = 0; i < cBlocks; i++)
57 {
58 uint32_t cbBlock;
59 vrc = SSMR3GetU32(pSSM, &cbBlock);
60 AssertRCBreak(vrc);
61
62 uint32_t typeOfBlock;
63 vrc = SSMR3GetU32(pSSM, &typeOfBlock);
64 AssertRCBreak(vrc);
65
66 LogFlowFunc(("[%d] type %d, size %d bytes\n", i, typeOfBlock, cbBlock));
67
68 if (typeOfBlock == u32Type)
69 {
70 if (cbBlock > 2 * sizeof(uint32_t))
71 {
72 cbData = cbBlock - 2 * sizeof(uint32_t);
73 pu8Data = (uint8_t *)RTMemAlloc(cbData);
74 if (pu8Data == NULL)
75 {
76 vrc = VERR_NO_MEMORY;
77 break;
78 }
79
80 vrc = SSMR3GetU32(pSSM, &u32Width);
81 AssertRCBreak(vrc);
82 vrc = SSMR3GetU32(pSSM, &u32Height);
83 AssertRCBreak(vrc);
84 vrc = SSMR3GetMem(pSSM, pu8Data, cbData);
85 AssertRCBreak(vrc);
86 }
87 else
88 {
89 /* No saved state data. */
90 vrc = VERR_NOT_SUPPORTED;
91 }
92
93 break;
94 }
95 else
96 {
97 /* displaySSMSaveScreenshot did not write any data, if
98 * cbBlock was == 2 * sizeof (uint32_t).
99 */
100 if (cbBlock > 2 * sizeof (uint32_t))
101 {
102 vrc = SSMR3Skip(pSSM, cbBlock);
103 AssertRCBreak(vrc);
104 }
105 }
106 }
107 }
108 else
109 {
110 vrc = VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
111 }
112 }
113
114 SSMR3Close(pSSM);
115 }
116
117 if (RT_SUCCESS(vrc))
118 {
119 if (u32Type == 0 && cbData % 4 != 0)
120 {
121 /* Bitmap is 32bpp, so data is invalid. */
122 vrc = VERR_SSM_UNEXPECTED_DATA;
123 }
124 }
125
126 if (RT_SUCCESS(vrc))
127 {
128 *ppu8Data = pu8Data;
129 *pcbData = cbData;
130 *pu32Width = u32Width;
131 *pu32Height = u32Height;
132 LogFlowFunc(("cbData %d, u32Width %d, u32Height %d\n", cbData, u32Width, u32Height));
133 }
134
135 LogFlowFunc(("vrc %Rrc\n", vrc));
136 return vrc;
137}
138
139void freeSavedDisplayScreenshot(uint8_t *pu8Data)
140{
141 /* @todo not necessary when caching is implemented. */
142 RTMemFree(pu8Data);
143}
144
145int readSavedGuestScreenInfo(const Utf8Str &strStateFilePath, uint32_t u32ScreenId,
146 uint32_t *pu32OriginX, uint32_t *pu32OriginY,
147 uint32_t *pu32Width, uint32_t *pu32Height, uint16_t *pu16Flags)
148{
149 LogFlowFunc(("u32ScreenId = %d [%s]\n", u32ScreenId, strStateFilePath.c_str()));
150
151 /* @todo cache read data */
152 if (strStateFilePath.isEmpty())
153 {
154 /* No saved state data. */
155 return VERR_NOT_SUPPORTED;
156 }
157
158 PSSMHANDLE pSSM;
159 int vrc = SSMR3Open(strStateFilePath.c_str(), 0 /*fFlags*/, &pSSM);
160 if (RT_SUCCESS(vrc))
161 {
162 uint32_t uVersion;
163 vrc = SSMR3Seek(pSSM, "DisplayData", 0 /*iInstance*/, &uVersion);
164 if (RT_SUCCESS(vrc))
165 {
166 /* Starting from sSSMDisplayVer2 we have pu32Width and pu32Height.
167 * Starting from sSSMDisplayVer3 we have all the rest of parameters we need. */
168 if (uVersion >= sSSMDisplayVer2)
169 {
170 uint32_t cMonitors;
171 SSMR3GetU32(pSSM, &cMonitors);
172 if (u32ScreenId > cMonitors)
173 {
174 vrc = VERR_INVALID_PARAMETER;
175 }
176 else
177 {
178 if (uVersion == sSSMDisplayVer2)
179 {
180 /* Skip all previous monitors, each 5 uint32_t, and the first 3 uint32_t entries. */
181 SSMR3Skip(pSSM, u32ScreenId * 5 * sizeof(uint32_t) + 3 * sizeof(uint32_t));
182 SSMR3GetU32(pSSM, pu32Width);
183 SSMR3GetU32(pSSM, pu32Height);
184 *pu32OriginX = 0;
185 *pu32OriginY = 0;
186 *pu16Flags = VBVA_SCREEN_F_ACTIVE;
187 }
188 else
189 {
190 /* Skip all previous monitors, each 8 uint32_t, and the first 3 uint32_t entries. */
191 SSMR3Skip(pSSM, u32ScreenId * 8 * sizeof(uint32_t) + 3 * sizeof(uint32_t));
192 SSMR3GetU32(pSSM, pu32Width);
193 SSMR3GetU32(pSSM, pu32Height);
194 SSMR3GetU32(pSSM, pu32OriginX);
195 SSMR3GetU32(pSSM, pu32OriginY);
196 uint32_t u32Flags = 0;
197 SSMR3GetU32(pSSM, &u32Flags);
198 *pu16Flags = (uint16_t)u32Flags;
199 }
200 }
201 }
202 else
203 {
204 vrc = VERR_NOT_SUPPORTED;
205 }
206 }
207
208 SSMR3Close(pSSM);
209 }
210
211 LogFlowFunc(("vrc %Rrc\n", vrc));
212 return vrc;
213}
214
Note: See TracBrowser for help on using the repository browser.

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