XLibre/xserver
1
1
Fork 0
mirror of https://github.com/X11Libre/xserver.git synced 2026-04-14 17:18:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

randr: inline byte-swapping into actual request handlers

Browse Source 
No need to have whole extra functions for just a few LoC, and in the
future the whole thing will become more simplified by generic macros.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>
This commit is contained in:
Enrico Weigelt, metux IT consult
2025-09-25 13:07:25 +02:00
committed by Enrico Weigelt
parent b2a85f070d
commit 5e38615365
14 changed files with 380 additions and 754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
randr/meson.build
View File

@@ -12,7 +12,6 @@ srcs_randr = [
'rrprovider.c',
'rrproviderproperty.c',
'rrscreen.c',
'rrsdispatch.c',
'rrtransform.c',
]

2
randr/randr.c
View File

@@ -414,7 +414,7 @@ RRExtensionInit(void)
if (!RREventType)
return;
extEntry = AddExtension(RANDR_NAME, RRNumberEvents, RRNumberErrors,
ProcRRDispatch, SProcRRDispatch,
ProcRRDispatch, ProcRRDispatch,
NULL, StandardMinorOpcode);
if (!extEntry)
return;

94
randr/rrcrtc.c
View File

@@ -1148,9 +1148,14 @@ int
ProcRRGetCrtcInfo(ClientPtr client)
{
REQUEST(xRRGetCrtcInfoReq);
RRCrtcPtr crtc;
REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
if (client->swapped) {
swapl(&stuff->crtc);
swapl(&stuff->configTimestamp);
}
RRCrtcPtr crtc;
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
Bool leased = RRCrtcIsLeased(crtc);
@@ -1241,6 +1246,19 @@ int
ProcRRSetCrtcConfig(ClientPtr client)
{
REQUEST(xRRSetCrtcConfigReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
if (client->swapped) {
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swapl(&stuff->configTimestamp);
swaps(&stuff->x);
swaps(&stuff->y);
swapl(&stuff->mode);
swaps(&stuff->rotation);
SwapRestL(stuff);
}
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
RRCrtcPtr crtc;
@@ -1253,7 +1271,6 @@ ProcRRSetCrtcConfig(ClientPtr client)
int ret, i, j;
CARD8 status;
REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
numOutputs = (client->req_len - bytes_to_int32(sizeof(xRRSetCrtcConfigReq)));
VERIFY_RR_CRTC(stuff->crtc, crtc, DixSetAttrAccess);
@@ -1448,6 +1465,11 @@ int
ProcRRGetPanning(ClientPtr client)
{
REQUEST(xRRGetPanningReq);
REQUEST_SIZE_MATCH(xRRGetPanningReq);
if (client->swapped)
swapl(&stuff->crtc);
RRCrtcPtr crtc;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
@@ -1455,7 +1477,6 @@ ProcRRGetPanning(ClientPtr client)
BoxRec tracking;
INT16 border[4];
REQUEST_SIZE_MATCH(xRRGetPanningReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
/* All crtcs must be associated with screens before client
@@ -1510,6 +1531,25 @@ int
ProcRRSetPanning(ClientPtr client)
{
REQUEST(xRRSetPanningReq);
REQUEST_SIZE_MATCH(xRRSetPanningReq);
if (client->swapped) {
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swaps(&stuff->left);
swaps(&stuff->top);
swaps(&stuff->width);
swaps(&stuff->height);
swaps(&stuff->track_left);
swaps(&stuff->track_top);
swaps(&stuff->track_width);
swaps(&stuff->track_height);
swaps(&stuff->border_left);
swaps(&stuff->border_top);
swaps(&stuff->border_right);
swaps(&stuff->border_bottom);
}
RRCrtcPtr crtc;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
@@ -1519,7 +1559,6 @@ ProcRRSetPanning(ClientPtr client)
INT16 border[4];
CARD8 status;
REQUEST_SIZE_MATCH(xRRSetPanningReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
if (RRCrtcIsLeased(crtc))
@@ -1578,9 +1617,13 @@ int
ProcRRGetCrtcGammaSize(ClientPtr client)
{
REQUEST(xRRGetCrtcGammaSizeReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
if (client->swapped)
swapl(&stuff->crtc);
RRCrtcPtr crtc;
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
/* Gamma retrieval failed, any better error? */
@@ -1600,9 +1643,12 @@ int
ProcRRGetCrtcGamma(ClientPtr client)
{
REQUEST(xRRGetCrtcGammaReq);
RRCrtcPtr crtc;
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
if (client->swapped)
swapl(&stuff->crtc);
RRCrtcPtr crtc;
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
/* Gamma retrieval failed, any better error? */
@@ -1630,11 +1676,18 @@ int
ProcRRSetCrtcGamma(ClientPtr client)
{
REQUEST(xRRSetCrtcGammaReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
if (client->swapped) {
swapl(&stuff->crtc);
swaps(&stuff->size);
SwapRestS(stuff);
}
RRCrtcPtr crtc;
unsigned long len;
CARD16 *red, *green, *blue;
REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
if (RRCrtcIsLeased(crtc))
@@ -1662,6 +1715,22 @@ int
ProcRRSetCrtcTransform(ClientPtr client)
{
REQUEST(xRRSetCrtcTransformReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
if (client->swapped) {
swapl(&stuff->crtc);
SwapLongs((CARD32 *) &stuff->transform,
bytes_to_int32(sizeof(xRenderTransform)));
swaps(&stuff->nbytesFilter);
char *filter = (char *) (stuff + 1);
CARD32 *params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
int nparams = ((CARD32 *) stuff + client->req_len) - params;
if (nparams < 0)
return BadLength;
SwapLongs(params, nparams);
}
RRCrtcPtr crtc;
PictTransform transform;
struct pixman_f_transform f_transform, f_inverse;
@@ -1670,7 +1739,6 @@ ProcRRSetCrtcTransform(ClientPtr client)
xFixed *params;
int nparams;
REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
if (RRCrtcIsLeased(crtc))
@@ -1696,10 +1764,14 @@ int
ProcRRGetCrtcTransform(ClientPtr client)
{
REQUEST(xRRGetCrtcTransformReq);
REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
if (client->swapped)
swapl(&stuff->crtc);
RRCrtcPtr crtc;
RRTransformPtr current, pending;
REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
pending = &crtc->client_pending_transform;

16
randr/rrdispatch.c
View File

@@ -42,9 +42,15 @@ int
ProcRRQueryVersion(ClientPtr client)
{
REQUEST(xRRQueryVersionReq);
REQUEST_SIZE_MATCH(xRRQueryVersionReq);
if (client->swapped) {
swapl(&stuff->majorVersion);
swapl(&stuff->minorVersion);
}
rrClientPriv(client);
REQUEST_SIZE_MATCH(xRRQueryVersionReq);
pRRClient->major_version = stuff->majorVersion;
pRRClient->minor_version = stuff->minorVersion;
@@ -72,6 +78,13 @@ int
ProcRRSelectInput(ClientPtr client)
{
REQUEST(xRRSelectInputReq);
REQUEST_SIZE_MATCH(xRRSelectInputReq);
if (client->swapped) {
swapl(&stuff->window);
swaps(&stuff->enable);
}
rrClientPriv(client);
RRTimesPtr pTimes;
WindowPtr pWin;
@@ -79,7 +92,6 @@ ProcRRSelectInput(ClientPtr client)
XID clientResource;
int rc;
REQUEST_SIZE_MATCH(xRRSelectInputReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
if (rc != Success)
return rc;

1
randr/rrdispatch_priv.h
View File

@@ -70,6 +70,5 @@ int ProcRRQueryVersion(ClientPtr client);
int ProcRRSelectInput(ClientPtr client);
int ProcRRDispatch(ClientPtr client);
int SProcRRDispatch(ClientPtr client);
#endif /* _XSERVER_RANDR_RRDISPATCH_H */

17
randr/rrlease.c
View File

@@ -215,6 +215,15 @@ int
ProcRRCreateLease(ClientPtr client)
{
REQUEST(xRRCreateLeaseReq);
REQUEST_AT_LEAST_SIZE(xRRCreateLeaseReq);
if (client->swapped) {
swapl(&stuff->window);
swaps(&stuff->nCrtcs);
swaps(&stuff->nOutputs);
SwapRestL(stuff);
}
WindowPtr window;
ScreenPtr screen;
rrScrPrivPtr scr_priv;
@@ -226,8 +235,6 @@ ProcRRCreateLease(ClientPtr client)
unsigned long len;
int c, o;
REQUEST_AT_LEAST_SIZE(xRRCreateLeaseReq);
LEGAL_NEW_RESOURCE(stuff->lid, client);
rc = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
@@ -350,10 +357,12 @@ int
ProcRRFreeLease(ClientPtr client)
{
REQUEST(xRRFreeLeaseReq);
RRLeasePtr lease;
REQUEST_SIZE_MATCH(xRRFreeLeaseReq);
if (client->swapped)
swapl(&stuff->lid);
RRLeasePtr lease;
VERIFY_RR_LEASE(stuff->lid, lease, DixDestroyAccess);
if (stuff->terminate)

51
randr/rrmode.c
View File

@@ -288,6 +288,25 @@ int
ProcRRCreateMode(ClientPtr client)
{
REQUEST(xRRCreateModeReq);
REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
if (client->swapped) {
swapl(&stuff->window);
xRRModeInfo *modeinfo = &stuff->modeInfo;
swapl(&modeinfo->id);
swaps(&modeinfo->width);
swaps(&modeinfo->height);
swapl(&modeinfo->dotClock);
swaps(&modeinfo->hSyncStart);
swaps(&modeinfo->hSyncEnd);
swaps(&modeinfo->hTotal);
swaps(&modeinfo->vSyncStart);
swaps(&modeinfo->vSyncEnd);
swaps(&modeinfo->vTotal);
swaps(&modeinfo->nameLength);
swapl(&modeinfo->modeFlags);
}
WindowPtr pWin;
ScreenPtr pScreen;
xRRModeInfo *modeInfo;
@@ -296,7 +315,6 @@ ProcRRCreateMode(ClientPtr client)
int error, rc;
RRModePtr mode;
REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -333,9 +351,12 @@ int
ProcRRDestroyMode(ClientPtr client)
{
REQUEST(xRRDestroyModeReq);
RRModePtr mode;
REQUEST_SIZE_MATCH(xRRDestroyModeReq);
if (client->swapped)
swapl(&stuff->mode);
RRModePtr mode;
VERIFY_RR_MODE(stuff->mode, mode, DixDestroyAccess);
if (!mode->userScreen)
@@ -350,11 +371,17 @@ int
ProcRRAddOutputMode(ClientPtr client)
{
REQUEST(xRRAddOutputModeReq);
RRModePtr mode;
RROutputPtr output;
REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->mode);
}
RROutputPtr output;
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
RRModePtr mode;
VERIFY_RR_MODE(stuff->mode, mode, DixUseAccess);
if (RROutputIsLeased(output))
@@ -367,11 +394,17 @@ int
ProcRRDeleteOutputMode(ClientPtr client)
{
REQUEST(xRRDeleteOutputModeReq);
RRModePtr mode;
RROutputPtr output;
REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->mode);
}
RROutputPtr output;
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
RRModePtr mode;
VERIFY_RR_MODE(stuff->mode, mode, DixUseAccess);
if (RROutputIsLeased(output))

30
randr/rrmonitor.c
View File

@@ -583,13 +583,18 @@ int
ProcRRGetMonitors(ClientPtr client)
{
REQUEST(xRRGetMonitorsReq);
REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
if (client->swapped)
swapl(&stuff->window);
WindowPtr window;
ScreenPtr screen;
int r;
RRMonitorPtr monitors;
int nmonitors;
Bool get_active;
REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
r = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
if (r != Success)
return r;
@@ -655,13 +660,24 @@ int
ProcRRSetMonitor(ClientPtr client)
{
REQUEST(xRRSetMonitorReq);
REQUEST_AT_LEAST_SIZE(xRRGetMonitorsReq);
if (client->swapped) {
swapl(&stuff->window);
swapl(&stuff->monitor.name);
swaps(&stuff->monitor.noutput);
swaps(&stuff->monitor.x);
swaps(&stuff->monitor.y);
swaps(&stuff->monitor.width);
swaps(&stuff->monitor.height);
SwapRestL(stuff);
}
WindowPtr window;
ScreenPtr screen;
RRMonitorPtr monitor;
int r;
REQUEST_AT_LEAST_SIZE(xRRSetMonitorReq);
if (stuff->monitor.noutput != client->req_len - (sizeof(xRRSetMonitorReq) >> 2))
return BadLength;
@@ -703,11 +719,17 @@ int
ProcRRDeleteMonitor(ClientPtr client)
{
REQUEST(xRRDeleteMonitorReq);
REQUEST_SIZE_MATCH(xRRDeleteMonitorReq);
if (client->swapped) {
swapl(&stuff->window);
swapl(&stuff->name);
}
WindowPtr window;
ScreenPtr screen;
int r;
REQUEST_SIZE_MATCH(xRRDeleteMonitorReq);
r = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
if (r != Success)
return r;

24
randr/rroutput.c
View File

@@ -446,13 +446,19 @@ int
ProcRRGetOutputInfo(ClientPtr client)
{
REQUEST(xRRGetOutputInfoReq);
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->configTimestamp);
}
RROutputPtr output;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
int i;
Bool leased;
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
leased = RROutputIsLeased(output);
@@ -540,14 +546,19 @@ int
ProcRRSetOutputPrimary(ClientPtr client)
{
REQUEST(xRRSetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
if (client->swapped) {
swapl(&stuff->window);
swapl(&stuff->output);
}
RROutputPtr output = NULL;
WindowPtr pWin;
rrScrPrivPtr pScrPriv;
int ret;
ScreenPtr secondary;
REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
ret = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (ret != Success)
return ret;
@@ -588,13 +599,16 @@ int
ProcRRGetOutputPrimary(ClientPtr client)
{
REQUEST(xRRGetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
if (client->swapped)
swapl(&stuff->window);
WindowPtr pWin;
rrScrPrivPtr pScrPriv;
RROutputPtr primary = NULL;
int rc;
REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;

63
randr/rrproperty.c
View File

@@ -420,6 +420,9 @@ ProcRRListOutputProperties(ClientPtr client)
REQUEST(xRRListOutputPropertiesReq);
REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
if (client->swapped)
swapl(&stuff->output);
RROutputPtr output;
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
@@ -446,10 +449,16 @@ int
ProcRRQueryOutputProperty(ClientPtr client)
{
REQUEST(xRRQueryOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->property);
}
RROutputPtr output;
RRPropertyPtr prop;
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
prop = RRQueryOutputProperty(output, stuff->property);
@@ -472,11 +481,17 @@ int
ProcRRConfigureOutputProperty(ClientPtr client)
{
REQUEST(xRRConfigureOutputPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->property);
SwapRestL(stuff);
}
RROutputPtr output;
int num_valid;
REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
if (RROutputIsLeased(output))
@@ -493,6 +508,28 @@ int
ProcRRChangeOutputProperty(ClientPtr client)
{
REQUEST(xRRChangeOutputPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch (stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
default:
client->errorValue = stuff->format;
return BadValue;
}
}
RROutputPtr output;
char format, mode;
unsigned long len;
@@ -500,7 +537,6 @@ ProcRRChangeOutputProperty(ClientPtr client)
uint64_t totalSize;
int err;
REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
UpdateCurrentTime();
format = stuff->format;
mode = stuff->mode;
@@ -545,10 +581,16 @@ int
ProcRRDeleteOutputProperty(ClientPtr client)
{
REQUEST(xRRDeleteOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->property);
}
RROutputPtr output;
RRPropertyPtr prop;
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
UpdateCurrentTime();
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
@@ -579,12 +621,21 @@ int
ProcRRGetOutputProperty(ClientPtr client)
{
REQUEST(xRRGetOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
if (client->swapped) {
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->longOffset);
swapl(&stuff->longLength);
}
RRPropertyPtr prop, *prev;
RRPropertyValuePtr prop_value;
unsigned long n, ind;
RROutputPtr output;
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
if (stuff->delete)
UpdateCurrentTime();
VERIFY_RR_OUTPUT(stuff->output, output,

34
randr/rrprovider.c
View File

@@ -56,13 +56,17 @@ int
ProcRRGetProviders (ClientPtr client)
{
REQUEST(xRRGetProvidersReq);
REQUEST_SIZE_MATCH(xRRGetProvidersReq);
if (client->swapped)
swapl(&stuff->window);
WindowPtr pWin;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
int rc;
ScreenPtr iter;
REQUEST_SIZE_MATCH(xRRGetProvidersReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -104,6 +108,13 @@ int
ProcRRGetProviderInfo (ClientPtr client)
{
REQUEST(xRRGetProviderInfoReq);
REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->configTimestamp);
}
rrScrPrivPtr pScrPriv, pScrProvPriv;
RRProviderPtr provider;
ScreenPtr pScreen;
@@ -117,7 +128,6 @@ ProcRRGetProviderInfo (ClientPtr client)
RRProvider *providers;
uint32_t *prov_cap;
REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
pScreen = provider->pScreen;
@@ -278,12 +288,18 @@ int
ProcRRSetProviderOutputSource(ClientPtr client)
{
REQUEST(xRRSetProviderOutputSourceReq);
REQUEST_SIZE_MATCH(xRRSetProviderOutputSourceReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->source_provider);
swapl(&stuff->configTimestamp);
}
rrScrPrivPtr pScrPriv;
RRProviderPtr provider, source_provider = NULL;
ScreenPtr pScreen;
REQUEST_SIZE_MATCH(xRRSetProviderOutputSourceReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
if (!(provider->capabilities & RR_Capability_SinkOutput))
@@ -318,12 +334,18 @@ int
ProcRRSetProviderOffloadSink(ClientPtr client)
{
REQUEST(xRRSetProviderOffloadSinkReq);
REQUEST_SIZE_MATCH(xRRSetProviderOffloadSinkReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->sink_provider);
swapl(&stuff->configTimestamp);
}
rrScrPrivPtr pScrPriv;
RRProviderPtr provider, sink_provider = NULL;
ScreenPtr pScreen;
REQUEST_SIZE_MATCH(xRRSetProviderOffloadSinkReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
if (!(provider->capabilities & RR_Capability_SourceOffload))
return BadValue;

66
randr/rrproviderproperty.c
View File

@@ -341,12 +341,15 @@ int
ProcRRListProviderProperties(ClientPtr client)
{
REQUEST(xRRListProviderPropertiesReq);
REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
if (client->swapped)
swapl(&stuff->provider);
int numProps = 0;
RRProviderPtr provider;
RRPropertyPtr prop;
REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
x_rpcbuf_t rpcbuf = { .swapped = client->swapped, .err_clear = TRUE };
@@ -370,11 +373,16 @@ int
ProcRRQueryProviderProperty(ClientPtr client)
{
REQUEST(xRRQueryProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->property);
}
RRProviderPtr provider;
RRPropertyPtr prop;
REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
prop = RRQueryProviderProperty(provider, stuff->property);
@@ -397,11 +405,18 @@ int
ProcRRConfigureProviderProperty(ClientPtr client)
{
REQUEST(xRRConfigureProviderPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRConfigureProviderPropertyReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->property);
/* TODO: no way to specify format? */
SwapRestL(stuff);
}
RRProviderPtr provider;
int num_valid;
REQUEST_AT_LEAST_SIZE(xRRConfigureProviderPropertyReq);
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
num_valid =
@@ -415,6 +430,25 @@ int
ProcRRChangeProviderProperty(ClientPtr client)
{
REQUEST(xRRChangeProviderPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRChangeProviderPropertyReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch (stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
}
}
RRProviderPtr provider;
char format, mode;
unsigned long len;
@@ -422,7 +456,6 @@ ProcRRChangeProviderProperty(ClientPtr client)
uint64_t totalSize;
int err;
REQUEST_AT_LEAST_SIZE(xRRChangeProviderPropertyReq);
UpdateCurrentTime();
format = stuff->format;
mode = stuff->mode;
@@ -467,10 +500,16 @@ int
ProcRRDeleteProviderProperty(ClientPtr client)
{
REQUEST(xRRDeleteProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteProviderPropertyReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->property);
}
RRProviderPtr provider;
RRPropertyPtr prop;
REQUEST_SIZE_MATCH(xRRDeleteProviderPropertyReq);
UpdateCurrentTime();
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
@@ -498,12 +537,21 @@ int
ProcRRGetProviderProperty(ClientPtr client)
{
REQUEST(xRRGetProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRGetProviderPropertyReq);
if (client->swapped) {
swapl(&stuff->provider);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->longOffset);
swapl(&stuff->longLength);
}
RRPropertyPtr prop, *prev;
RRPropertyValuePtr prop_value;
unsigned long n, len, ind;
RRProviderPtr provider;
REQUEST_SIZE_MATCH(xRRGetProviderPropertyReq);
if (stuff->delete)
UpdateCurrentTime();
VERIFY_RR_PROVIDER(stuff->provider, provider,

63
randr/rrscreen.c
View File

@@ -192,12 +192,15 @@ int
ProcRRGetScreenSizeRange(ClientPtr client)
{
REQUEST(xRRGetScreenSizeRangeReq);
REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
if (client->swapped)
swapl(&stuff->window);
WindowPtr pWin;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
int rc;
REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -232,12 +235,20 @@ int
ProcRRSetScreenSize(ClientPtr client)
{
REQUEST(xRRSetScreenSizeReq);
REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
if (client->swapped) {
swapl(&stuff->window);
swaps(&stuff->width);
swaps(&stuff->height);
swapl(&stuff->widthInMillimeters);
swapl(&stuff->heightInMillimeters);
}
WindowPtr pWin;
ScreenPtr pScreen;
rrScrPrivPtr pScrPriv;
int i, rc;
REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -472,6 +483,11 @@ static int
rrGetScreenResources(ClientPtr client, Bool query)
{
REQUEST(xRRGetScreenResourcesReq);
REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
if (client->swapped)
swapl(&stuff->window);
xRRGetScreenResourcesReply rep;
WindowPtr pWin;
ScreenPtr pScreen;
@@ -480,7 +496,6 @@ rrGetScreenResources(ClientPtr client, Bool query)
unsigned long extraLen = 0;
int i, rc, has_primary = 0;
REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -718,6 +733,10 @@ int
ProcRRGetScreenInfo(ClientPtr client)
{
REQUEST(xRRGetScreenInfoReq);
REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
if (client->swapped)
swapl(&stuff->window);
xRRGetScreenInfoReply rep;
WindowPtr pWin;
int rc;
@@ -727,7 +746,6 @@ ProcRRGetScreenInfo(ClientPtr client)
unsigned long extraLen = 0;
RROutputPtr output;
REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
@@ -847,6 +865,24 @@ int
ProcRRSetScreenConfig(ClientPtr client)
{
REQUEST(xRRSetScreenConfigReq);
int rate = 0;
if (RRClientKnowsRates(client)) {
REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
if (client->swapped) swaps(&stuff->rate);
rate = stuff->rate;
}
else {
REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
}
if (client->swapped) {
swapl(&stuff->drawable);
swapl(&stuff->timestamp);
swaps(&stuff->sizeID);
swaps(&stuff->rotation);
}
DrawablePtr pDraw;
int rc;
ScreenPtr pScreen;
@@ -854,8 +890,6 @@ ProcRRSetScreenConfig(ClientPtr client)
TimeStamp time;
int i;
Rotation rotation;
int rate;
Bool has_rate;
CARD8 status;
RROutputPtr output;
RRCrtcPtr crtc;
@@ -866,15 +900,6 @@ ProcRRSetScreenConfig(ClientPtr client)
UpdateCurrentTime();
if (RRClientKnowsRates(client)) {
REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
has_rate = TRUE;
}
else {
REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
has_rate = FALSE;
}
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0, DixWriteAccess);
if (rc != Success)
return rc;
@@ -960,14 +985,6 @@ ProcRRSetScreenConfig(ClientPtr client)
return BadMatch;
}
/*
* Validate requested refresh
*/
if (has_rate)
rate = (int) stuff->rate;
else
rate = 0;
if (rate) {
for (i = 0; i < pSize->nRates; i++) {
if (pSize->pRates[i].rate == rate)

672
randr/rrsdispatch.c
View File

@@ -1,672 +0,0 @@
/*
* Copyright © 2006 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders make no representations
* about the suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include <dix-config.h>
#include "randr/randrstr_priv.h"
#include "randr/rrdispatch_priv.h"
static int _X_COLD
SProcRRQueryVersion(ClientPtr client)
{
REQUEST(xRRQueryVersionReq);
REQUEST_SIZE_MATCH(xRRQueryVersionReq);
swapl(&stuff->majorVersion);
swapl(&stuff->minorVersion);
return ProcRRQueryVersion(client);
}
static int _X_COLD
SProcRRGetScreenInfo(ClientPtr client)
{
REQUEST(xRRGetScreenInfoReq);
REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
swapl(&stuff->window);
return ProcRRGetScreenInfo(client);
}
static int _X_COLD
SProcRRSetScreenConfig(ClientPtr client)
{
REQUEST(xRRSetScreenConfigReq);
if (RRClientKnowsRates(client)) {
REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
swaps(&stuff->rate);
}
else {
REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
}
swapl(&stuff->drawable);
swapl(&stuff->timestamp);
swaps(&stuff->sizeID);
swaps(&stuff->rotation);
return ProcRRSetScreenConfig(client);
}
static int _X_COLD
SProcRRSelectInput(ClientPtr client)
{
REQUEST(xRRSelectInputReq);
REQUEST_SIZE_MATCH(xRRSelectInputReq);
swapl(&stuff->window);
swaps(&stuff->enable);
return ProcRRSelectInput(client);
}
static int _X_COLD
SProcRRGetScreenSizeRange(ClientPtr client)
{
REQUEST(xRRGetScreenSizeRangeReq);
REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
swapl(&stuff->window);
return ProcRRGetScreenSizeRange(client);
}
static int _X_COLD
SProcRRSetScreenSize(ClientPtr client)
{
REQUEST(xRRSetScreenSizeReq);
REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
swapl(&stuff->window);
swaps(&stuff->width);
swaps(&stuff->height);
swapl(&stuff->widthInMillimeters);
swapl(&stuff->heightInMillimeters);
return ProcRRSetScreenSize(client);
}
static int _X_COLD
SProcRRGetScreenResources(ClientPtr client)
{
REQUEST(xRRGetScreenResourcesReq);
REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
swapl(&stuff->window);
return ProcRRGetScreenResources(client);
}
static int _X_COLD
SProcRRGetScreenResourcesCurrent(ClientPtr client)
{
REQUEST(xRRGetScreenResourcesCurrentReq);
REQUEST_SIZE_MATCH(xRRGetScreenResourcesCurrentReq);
swapl(&stuff->window);
return ProcRRGetScreenResourcesCurrent(client);
}
static int _X_COLD
SProcRRGetOutputInfo(ClientPtr client)
{
REQUEST(xRRGetOutputInfoReq);
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
swapl(&stuff->output);
swapl(&stuff->configTimestamp);
return ProcRRGetScreenResources(client);
}
static int _X_COLD
SProcRRListOutputProperties(ClientPtr client)
{
REQUEST(xRRListOutputPropertiesReq);
REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
swapl(&stuff->output);
return ProcRRListOutputProperties(client);
}
static int _X_COLD
SProcRRQueryOutputProperty(ClientPtr client)
{
REQUEST(xRRQueryOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
swapl(&stuff->output);
swapl(&stuff->property);
return ProcRRQueryOutputProperty(client);
}
static int _X_COLD
SProcRRConfigureOutputProperty(ClientPtr client)
{
REQUEST(xRRConfigureOutputPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
swapl(&stuff->output);
swapl(&stuff->property);
SwapRestL(stuff);
return ProcRRConfigureOutputProperty(client);
}
static int _X_COLD
SProcRRChangeOutputProperty(ClientPtr client)
{
REQUEST(xRRChangeOutputPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch (stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
default:
client->errorValue = stuff->format;
return BadValue;
}
return ProcRRChangeOutputProperty(client);
}
static int _X_COLD
SProcRRDeleteOutputProperty(ClientPtr client)
{
REQUEST(xRRDeleteOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
swapl(&stuff->output);
swapl(&stuff->property);
return ProcRRDeleteOutputProperty(client);
}
static int _X_COLD
SProcRRGetOutputProperty(ClientPtr client)
{
REQUEST(xRRGetOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
swapl(&stuff->output);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->longOffset);
swapl(&stuff->longLength);
return ProcRRGetOutputProperty(client);
}
static int _X_COLD
SProcRRCreateMode(ClientPtr client)
{
xRRModeInfo *modeinfo;
REQUEST(xRRCreateModeReq);
REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
swapl(&stuff->window);
modeinfo = &stuff->modeInfo;
swapl(&modeinfo->id);
swaps(&modeinfo->width);
swaps(&modeinfo->height);
swapl(&modeinfo->dotClock);
swaps(&modeinfo->hSyncStart);
swaps(&modeinfo->hSyncEnd);
swaps(&modeinfo->hTotal);
swaps(&modeinfo->vSyncStart);
swaps(&modeinfo->vSyncEnd);
swaps(&modeinfo->vTotal);
swaps(&modeinfo->nameLength);
swapl(&modeinfo->modeFlags);
return ProcRRCreateMode(client);
}
static int _X_COLD
SProcRRDestroyMode(ClientPtr client)
{
REQUEST(xRRDestroyModeReq);
REQUEST_SIZE_MATCH(xRRDestroyModeReq);
swapl(&stuff->mode);
return ProcRRDestroyMode(client);
}
static int _X_COLD
SProcRRAddOutputMode(ClientPtr client)
{
REQUEST(xRRAddOutputModeReq);
REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
swapl(&stuff->output);
swapl(&stuff->mode);
return ProcRRAddOutputMode(client);
}
static int _X_COLD
SProcRRDeleteOutputMode(ClientPtr client)
{
REQUEST(xRRDeleteOutputModeReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
swapl(&stuff->output);
swapl(&stuff->mode);
return ProcRRDeleteOutputMode(client);
}
static int _X_COLD
SProcRRGetCrtcInfo(ClientPtr client)
{
REQUEST(xRRGetCrtcInfoReq);
REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
swapl(&stuff->crtc);
swapl(&stuff->configTimestamp);
return ProcRRGetCrtcInfo(client);
}
static int _X_COLD
SProcRRSetCrtcConfig(ClientPtr client)
{
REQUEST(xRRSetCrtcConfigReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swapl(&stuff->configTimestamp);
swaps(&stuff->x);
swaps(&stuff->y);
swapl(&stuff->mode);
swaps(&stuff->rotation);
SwapRestL(stuff);
return ProcRRSetCrtcConfig(client);
}
static int _X_COLD
SProcRRGetCrtcGammaSize(ClientPtr client)
{
REQUEST(xRRGetCrtcGammaSizeReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
swapl(&stuff->crtc);
return ProcRRGetCrtcGammaSize(client);
}
static int _X_COLD
SProcRRGetCrtcGamma(ClientPtr client)
{
REQUEST(xRRGetCrtcGammaReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
swapl(&stuff->crtc);
return ProcRRGetCrtcGamma(client);
}
static int _X_COLD
SProcRRSetCrtcGamma(ClientPtr client)
{
REQUEST(xRRSetCrtcGammaReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
swapl(&stuff->crtc);
swaps(&stuff->size);
SwapRestS(stuff);
return ProcRRSetCrtcGamma(client);
}
static int _X_COLD
SProcRRSetCrtcTransform(ClientPtr client)
{
int nparams;
char *filter;
CARD32 *params;
REQUEST(xRRSetCrtcTransformReq);
REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
swapl(&stuff->crtc);
SwapLongs((CARD32 *) &stuff->transform,
bytes_to_int32(sizeof(xRenderTransform)));
swaps(&stuff->nbytesFilter);
filter = (char *) (stuff + 1);
params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
nparams = ((CARD32 *) stuff + client->req_len) - params;
if (nparams < 0)
return BadLength;
SwapLongs(params, nparams);
return ProcRRSetCrtcTransform(client);
}
static int _X_COLD
SProcRRGetCrtcTransform(ClientPtr client)
{
REQUEST(xRRGetCrtcTransformReq);
REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
swapl(&stuff->crtc);
return ProcRRGetCrtcTransform(client);
}
static int _X_COLD
SProcRRGetPanning(ClientPtr client)
{
REQUEST(xRRGetPanningReq);
REQUEST_SIZE_MATCH(xRRGetPanningReq);
swapl(&stuff->crtc);
return ProcRRGetPanning(client);
}
static int _X_COLD
SProcRRSetPanning(ClientPtr client)
{
REQUEST(xRRSetPanningReq);
REQUEST_SIZE_MATCH(xRRSetPanningReq);
swapl(&stuff->crtc);
swapl(&stuff->timestamp);
swaps(&stuff->left);
swaps(&stuff->top);
swaps(&stuff->width);
swaps(&stuff->height);
swaps(&stuff->track_left);
swaps(&stuff->track_top);
swaps(&stuff->track_width);
swaps(&stuff->track_height);
swaps(&stuff->border_left);
swaps(&stuff->border_top);
swaps(&stuff->border_right);
swaps(&stuff->border_bottom);
return ProcRRSetPanning(client);
}
static int _X_COLD
SProcRRSetOutputPrimary(ClientPtr client)
{
REQUEST(xRRSetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
swapl(&stuff->window);
swapl(&stuff->output);
return ProcRRSetOutputPrimary(client);
}
static int _X_COLD
SProcRRGetOutputPrimary(ClientPtr client)
{
REQUEST(xRRGetOutputPrimaryReq);
REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
swapl(&stuff->window);
return ProcRRGetOutputPrimary(client);
}
static int _X_COLD
SProcRRGetProviders(ClientPtr client)
{
REQUEST(xRRGetProvidersReq);
REQUEST_SIZE_MATCH(xRRGetProvidersReq);
swapl(&stuff->window);
return ProcRRGetProviders(client);
}
static int _X_COLD
SProcRRGetProviderInfo(ClientPtr client)
{
REQUEST(xRRGetProviderInfoReq);
REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
swapl(&stuff->provider);
swapl(&stuff->configTimestamp);
return ProcRRGetProviderInfo(client);
}
static int _X_COLD
SProcRRSetProviderOffloadSink(ClientPtr client)
{
REQUEST(xRRSetProviderOffloadSinkReq);
REQUEST_SIZE_MATCH(xRRSetProviderOffloadSinkReq);
swapl(&stuff->provider);
swapl(&stuff->sink_provider);
swapl(&stuff->configTimestamp);
return ProcRRSetProviderOffloadSink(client);
}
static int _X_COLD
SProcRRSetProviderOutputSource(ClientPtr client)
{
REQUEST(xRRSetProviderOutputSourceReq);
REQUEST_SIZE_MATCH(xRRSetProviderOutputSourceReq);
swapl(&stuff->provider);
swapl(&stuff->source_provider);
swapl(&stuff->configTimestamp);
return ProcRRSetProviderOutputSource(client);
}
static int _X_COLD
SProcRRListProviderProperties(ClientPtr client)
{
REQUEST(xRRListProviderPropertiesReq);
REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
swapl(&stuff->provider);
return ProcRRListProviderProperties(client);
}
static int _X_COLD
SProcRRQueryProviderProperty(ClientPtr client)
{
REQUEST(xRRQueryProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
swapl(&stuff->provider);
swapl(&stuff->property);
return ProcRRQueryProviderProperty(client);
}
static int _X_COLD
SProcRRConfigureProviderProperty(ClientPtr client)
{
REQUEST(xRRConfigureProviderPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRConfigureProviderPropertyReq);
swapl(&stuff->provider);
swapl(&stuff->property);
/* TODO: no way to specify format? */
SwapRestL(stuff);
return ProcRRConfigureProviderProperty(client);
}
static int _X_COLD
SProcRRChangeProviderProperty(ClientPtr client)
{
REQUEST(xRRChangeProviderPropertyReq);
REQUEST_AT_LEAST_SIZE(xRRChangeProviderPropertyReq);
swapl(&stuff->provider);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch (stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
}
return ProcRRChangeProviderProperty(client);
}
static int _X_COLD
SProcRRDeleteProviderProperty(ClientPtr client)
{
REQUEST(xRRDeleteProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteProviderPropertyReq);
swapl(&stuff->provider);
swapl(&stuff->property);
return ProcRRDeleteProviderProperty(client);
}
static int _X_COLD
SProcRRGetProviderProperty(ClientPtr client)
{
REQUEST(xRRGetProviderPropertyReq);
REQUEST_SIZE_MATCH(xRRGetProviderPropertyReq);
swapl(&stuff->provider);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->longOffset);
swapl(&stuff->longLength);
return ProcRRGetProviderProperty(client);
}
static int _X_COLD
SProcRRGetMonitors(ClientPtr client) {
REQUEST(xRRGetMonitorsReq);
REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
swapl(&stuff->window);
return ProcRRGetMonitors(client);
}
static int _X_COLD
SProcRRSetMonitor(ClientPtr client) {
REQUEST(xRRSetMonitorReq);
REQUEST_AT_LEAST_SIZE(xRRGetMonitorsReq);
swapl(&stuff->window);
swapl(&stuff->monitor.name);
swaps(&stuff->monitor.noutput);
swaps(&stuff->monitor.x);
swaps(&stuff->monitor.y);
swaps(&stuff->monitor.width);
swaps(&stuff->monitor.height);
SwapRestL(stuff);
return ProcRRSetMonitor(client);
}
static int _X_COLD
SProcRRDeleteMonitor(ClientPtr client) {
REQUEST(xRRDeleteMonitorReq);
REQUEST_SIZE_MATCH(xRRDeleteMonitorReq);
swapl(&stuff->window);
swapl(&stuff->name);
return ProcRRDeleteMonitor(client);
}
static int _X_COLD
SProcRRCreateLease(ClientPtr client) {
REQUEST(xRRCreateLeaseReq);
REQUEST_AT_LEAST_SIZE(xRRCreateLeaseReq);
swapl(&stuff->window);
swaps(&stuff->nCrtcs);
swaps(&stuff->nOutputs);
SwapRestL(stuff);
return ProcRRCreateLease(client);
}
static int _X_COLD
SProcRRFreeLease(ClientPtr client) {
REQUEST(xRRFreeLeaseReq);
REQUEST_SIZE_MATCH(xRRFreeLeaseReq);
swapl(&stuff->lid);
return ProcRRFreeLease(client);
}
int
SProcRRDispatch(ClientPtr client)
{
REQUEST(xReq);
UpdateCurrentTimeIf();
switch (stuff->data) {
case X_RRQueryVersion: return SProcRRQueryVersion(client);
case X_RRSetScreenConfig: return SProcRRSetScreenConfig(client);
case X_RRSelectInput: return SProcRRSelectInput(client);
case X_RRGetScreenInfo: return SProcRRGetScreenInfo(client);
/* V1.2 additions */
case X_RRGetScreenSizeRange: return SProcRRGetScreenSizeRange(client);
case X_RRSetScreenSize: return SProcRRSetScreenSize(client);
case X_RRGetScreenResources: return SProcRRGetScreenResources(client);
case X_RRGetOutputInfo: return SProcRRGetOutputInfo(client);
case X_RRListOutputProperties: return SProcRRListOutputProperties(client);
case X_RRQueryOutputProperty: return SProcRRQueryOutputProperty(client);
case X_RRConfigureOutputProperty: return SProcRRConfigureOutputProperty(client);
case X_RRChangeOutputProperty: return SProcRRChangeOutputProperty(client);
case X_RRDeleteOutputProperty: return SProcRRDeleteOutputProperty(client);
case X_RRGetOutputProperty: return SProcRRGetOutputProperty(client);
case X_RRCreateMode: return SProcRRCreateMode(client);
case X_RRDestroyMode: return SProcRRDestroyMode(client);
case X_RRAddOutputMode: return SProcRRAddOutputMode(client);
case X_RRDeleteOutputMode: return SProcRRDeleteOutputMode(client);
case X_RRGetCrtcInfo: return SProcRRGetCrtcInfo(client);
case X_RRSetCrtcConfig: return SProcRRSetCrtcConfig(client);
case X_RRGetCrtcGammaSize: return SProcRRGetCrtcGammaSize(client);
case X_RRGetCrtcGamma: return SProcRRGetCrtcGamma(client);
case X_RRSetCrtcGamma: return SProcRRSetCrtcGamma(client);
/* V1.3 additions */
case X_RRGetScreenResourcesCurrent: return SProcRRGetScreenResourcesCurrent(client);
case X_RRSetCrtcTransform: return SProcRRSetCrtcTransform(client);
case X_RRGetCrtcTransform: return SProcRRGetCrtcTransform(client);
case X_RRGetPanning: return SProcRRGetPanning(client);
case X_RRSetPanning: return SProcRRSetPanning(client);
case X_RRSetOutputPrimary: return SProcRRSetOutputPrimary(client);
case X_RRGetOutputPrimary: return SProcRRGetOutputPrimary(client);
/* V1.4 additions */
case X_RRGetProviders: return SProcRRGetProviders(client);
case X_RRGetProviderInfo: return SProcRRGetProviderInfo(client);
case X_RRSetProviderOffloadSink: return SProcRRSetProviderOffloadSink(client);
case X_RRSetProviderOutputSource: return SProcRRSetProviderOutputSource(client);
case X_RRListProviderProperties: return SProcRRListProviderProperties(client);
case X_RRQueryProviderProperty: return SProcRRQueryProviderProperty(client);
case X_RRConfigureProviderProperty: return SProcRRConfigureProviderProperty(client);
case X_RRChangeProviderProperty: return SProcRRChangeProviderProperty(client);
case X_RRDeleteProviderProperty: return SProcRRDeleteProviderProperty(client);
case X_RRGetProviderProperty: return SProcRRGetProviderProperty(client);
/* V1.5 additions */
case X_RRGetMonitors: return SProcRRGetMonitors(client);
case X_RRSetMonitor: return SProcRRSetMonitor(client);
case X_RRDeleteMonitor: return SProcRRDeleteMonitor(client);
/* V1.6 additions */
case X_RRCreateLease: return SProcRRCreateLease(client);
case X_RRFreeLease: return SProcRRFreeLease(client);
}
return BadRequest;
}