1/*
2 * Copyright © 2006 Keith Packard
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission.  The copyright holders make no representations
11 * about the suitability of this software for any purpose.  It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
23#include "randrstr.h"
24
25static int _X_COLD
26SProcRRQueryVersion(ClientPtr client)
27{
28    REQUEST(xRRQueryVersionReq);
29
30    REQUEST_SIZE_MATCH(xRRQueryVersionReq);
31    swaps(&stuff->length);
32    swapl(&stuff->majorVersion);
33    swapl(&stuff->minorVersion);
34    return (*ProcRandrVector[stuff->randrReqType]) (client);
35}
36
37static int _X_COLD
38SProcRRGetScreenInfo(ClientPtr client)
39{
40    REQUEST(xRRGetScreenInfoReq);
41
42    REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
43    swaps(&stuff->length);
44    swapl(&stuff->window);
45    return (*ProcRandrVector[stuff->randrReqType]) (client);
46}
47
48static int _X_COLD
49SProcRRSetScreenConfig(ClientPtr client)
50{
51    REQUEST(xRRSetScreenConfigReq);
52
53    if (RRClientKnowsRates(client)) {
54        REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
55        swaps(&stuff->rate);
56    }
57    else {
58        REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
59    }
60
61    swaps(&stuff->length);
62    swapl(&stuff->drawable);
63    swapl(&stuff->timestamp);
64    swaps(&stuff->sizeID);
65    swaps(&stuff->rotation);
66    return (*ProcRandrVector[stuff->randrReqType]) (client);
67}
68
69static int _X_COLD
70SProcRRSelectInput(ClientPtr client)
71{
72    REQUEST(xRRSelectInputReq);
73
74    REQUEST_SIZE_MATCH(xRRSelectInputReq);
75    swaps(&stuff->length);
76    swapl(&stuff->window);
77    swaps(&stuff->enable);
78    return (*ProcRandrVector[stuff->randrReqType]) (client);
79}
80
81static int _X_COLD
82SProcRRGetScreenSizeRange(ClientPtr client)
83{
84    REQUEST(xRRGetScreenSizeRangeReq);
85
86    REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
87    swaps(&stuff->length);
88    swapl(&stuff->window);
89    return (*ProcRandrVector[stuff->randrReqType]) (client);
90}
91
92static int _X_COLD
93SProcRRSetScreenSize(ClientPtr client)
94{
95    REQUEST(xRRSetScreenSizeReq);
96
97    REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
98    swaps(&stuff->length);
99    swapl(&stuff->window);
100    swaps(&stuff->width);
101    swaps(&stuff->height);
102    swapl(&stuff->widthInMillimeters);
103    swapl(&stuff->heightInMillimeters);
104    return (*ProcRandrVector[stuff->randrReqType]) (client);
105}
106
107static int _X_COLD
108SProcRRGetScreenResources(ClientPtr client)
109{
110    REQUEST(xRRGetScreenResourcesReq);
111
112    REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
113    swaps(&stuff->length);
114    swapl(&stuff->window);
115    return (*ProcRandrVector[stuff->randrReqType]) (client);
116}
117
118static int _X_COLD
119SProcRRGetOutputInfo(ClientPtr client)
120{
121    REQUEST(xRRGetOutputInfoReq);
122
123    REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
124    swaps(&stuff->length);
125    swapl(&stuff->output);
126    swapl(&stuff->configTimestamp);
127    return (*ProcRandrVector[stuff->randrReqType]) (client);
128}
129
130static int _X_COLD
131SProcRRListOutputProperties(ClientPtr client)
132{
133    REQUEST(xRRListOutputPropertiesReq);
134
135    REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
136    swaps(&stuff->length);
137    swapl(&stuff->output);
138    return (*ProcRandrVector[stuff->randrReqType]) (client);
139}
140
141static int _X_COLD
142SProcRRQueryOutputProperty(ClientPtr client)
143{
144    REQUEST(xRRQueryOutputPropertyReq);
145
146    REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
147    swaps(&stuff->length);
148    swapl(&stuff->output);
149    swapl(&stuff->property);
150    return (*ProcRandrVector[stuff->randrReqType]) (client);
151}
152
153static int _X_COLD
154SProcRRConfigureOutputProperty(ClientPtr client)
155{
156    REQUEST(xRRConfigureOutputPropertyReq);
157
158    REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
159    swaps(&stuff->length);
160    swapl(&stuff->output);
161    swapl(&stuff->property);
162    SwapRestL(stuff);
163    return (*ProcRandrVector[stuff->randrReqType]) (client);
164}
165
166static int _X_COLD
167SProcRRChangeOutputProperty(ClientPtr client)
168{
169    REQUEST(xRRChangeOutputPropertyReq);
170
171    REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
172    swaps(&stuff->length);
173    swapl(&stuff->output);
174    swapl(&stuff->property);
175    swapl(&stuff->type);
176    swapl(&stuff->nUnits);
177    switch (stuff->format) {
178    case 8:
179        break;
180    case 16:
181        SwapRestS(stuff);
182        break;
183    case 32:
184        SwapRestL(stuff);
185        break;
186    default:
187        client->errorValue = stuff->format;
188        return BadValue;
189    }
190    return (*ProcRandrVector[stuff->randrReqType]) (client);
191}
192
193static int _X_COLD
194SProcRRDeleteOutputProperty(ClientPtr client)
195{
196    REQUEST(xRRDeleteOutputPropertyReq);
197
198    REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
199    swaps(&stuff->length);
200    swapl(&stuff->output);
201    swapl(&stuff->property);
202    return (*ProcRandrVector[stuff->randrReqType]) (client);
203}
204
205static int _X_COLD
206SProcRRGetOutputProperty(ClientPtr client)
207{
208    REQUEST(xRRGetOutputPropertyReq);
209
210    REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
211    swaps(&stuff->length);
212    swapl(&stuff->output);
213    swapl(&stuff->property);
214    swapl(&stuff->type);
215    swapl(&stuff->longOffset);
216    swapl(&stuff->longLength);
217    return (*ProcRandrVector[stuff->randrReqType]) (client);
218}
219
220static int _X_COLD
221SProcRRCreateMode(ClientPtr client)
222{
223    xRRModeInfo *modeinfo;
224
225    REQUEST(xRRCreateModeReq);
226
227    REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
228    swaps(&stuff->length);
229    swapl(&stuff->window);
230
231    modeinfo = &stuff->modeInfo;
232    swapl(&modeinfo->id);
233    swaps(&modeinfo->width);
234    swaps(&modeinfo->height);
235    swapl(&modeinfo->dotClock);
236    swaps(&modeinfo->hSyncStart);
237    swaps(&modeinfo->hSyncEnd);
238    swaps(&modeinfo->hTotal);
239    swaps(&modeinfo->vSyncStart);
240    swaps(&modeinfo->vSyncEnd);
241    swaps(&modeinfo->vTotal);
242    swaps(&modeinfo->nameLength);
243    swapl(&modeinfo->modeFlags);
244    return (*ProcRandrVector[stuff->randrReqType]) (client);
245}
246
247static int _X_COLD
248SProcRRDestroyMode(ClientPtr client)
249{
250    REQUEST(xRRDestroyModeReq);
251
252    REQUEST_SIZE_MATCH(xRRDestroyModeReq);
253    swaps(&stuff->length);
254    swapl(&stuff->mode);
255    return (*ProcRandrVector[stuff->randrReqType]) (client);
256}
257
258static int _X_COLD
259SProcRRAddOutputMode(ClientPtr client)
260{
261    REQUEST(xRRAddOutputModeReq);
262
263    REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
264    swaps(&stuff->length);
265    swapl(&stuff->output);
266    swapl(&stuff->mode);
267    return (*ProcRandrVector[stuff->randrReqType]) (client);
268}
269
270static int _X_COLD
271SProcRRDeleteOutputMode(ClientPtr client)
272{
273    REQUEST(xRRDeleteOutputModeReq);
274
275    REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
276    swaps(&stuff->length);
277    swapl(&stuff->output);
278    swapl(&stuff->mode);
279    return (*ProcRandrVector[stuff->randrReqType]) (client);
280}
281
282static int _X_COLD
283SProcRRGetCrtcInfo(ClientPtr client)
284{
285    REQUEST(xRRGetCrtcInfoReq);
286
287    REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
288    swaps(&stuff->length);
289    swapl(&stuff->crtc);
290    swapl(&stuff->configTimestamp);
291    return (*ProcRandrVector[stuff->randrReqType]) (client);
292}
293
294static int _X_COLD
295SProcRRSetCrtcConfig(ClientPtr client)
296{
297    REQUEST(xRRSetCrtcConfigReq);
298
299    REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
300    swaps(&stuff->length);
301    swapl(&stuff->crtc);
302    swapl(&stuff->timestamp);
303    swapl(&stuff->configTimestamp);
304    swaps(&stuff->x);
305    swaps(&stuff->y);
306    swapl(&stuff->mode);
307    swaps(&stuff->rotation);
308    SwapRestL(stuff);
309    return (*ProcRandrVector[stuff->randrReqType]) (client);
310}
311
312static int _X_COLD
313SProcRRGetCrtcGammaSize(ClientPtr client)
314{
315    REQUEST(xRRGetCrtcGammaSizeReq);
316
317    REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
318    swaps(&stuff->length);
319    swapl(&stuff->crtc);
320    return (*ProcRandrVector[stuff->randrReqType]) (client);
321}
322
323static int _X_COLD
324SProcRRGetCrtcGamma(ClientPtr client)
325{
326    REQUEST(xRRGetCrtcGammaReq);
327
328    REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
329    swaps(&stuff->length);
330    swapl(&stuff->crtc);
331    return (*ProcRandrVector[stuff->randrReqType]) (client);
332}
333
334static int _X_COLD
335SProcRRSetCrtcGamma(ClientPtr client)
336{
337    REQUEST(xRRSetCrtcGammaReq);
338
339    REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
340    swaps(&stuff->length);
341    swapl(&stuff->crtc);
342    swaps(&stuff->size);
343    SwapRestS(stuff);
344    return (*ProcRandrVector[stuff->randrReqType]) (client);
345}
346
347static int _X_COLD
348SProcRRSetCrtcTransform(ClientPtr client)
349{
350    int nparams;
351    char *filter;
352    CARD32 *params;
353
354    REQUEST(xRRSetCrtcTransformReq);
355
356    REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
357    swaps(&stuff->length);
358    swapl(&stuff->crtc);
359    SwapLongs((CARD32 *) &stuff->transform,
360              bytes_to_int32(sizeof(xRenderTransform)));
361    swaps(&stuff->nbytesFilter);
362    filter = (char *) (stuff + 1);
363    params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
364    nparams = ((CARD32 *) stuff + client->req_len) - params;
365    if (nparams < 0)
366        return BadLength;
367
368    SwapLongs(params, nparams);
369    return (*ProcRandrVector[stuff->randrReqType]) (client);
370}
371
372static int _X_COLD
373SProcRRGetCrtcTransform(ClientPtr client)
374{
375    REQUEST(xRRGetCrtcTransformReq);
376
377    REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
378    swaps(&stuff->length);
379    swapl(&stuff->crtc);
380    return (*ProcRandrVector[stuff->randrReqType]) (client);
381}
382
383static int _X_COLD
384SProcRRGetPanning(ClientPtr client)
385{
386    REQUEST(xRRGetPanningReq);
387
388    REQUEST_SIZE_MATCH(xRRGetPanningReq);
389    swaps(&stuff->length);
390    swapl(&stuff->crtc);
391    return (*ProcRandrVector[stuff->randrReqType]) (client);
392}
393
394static int _X_COLD
395SProcRRSetPanning(ClientPtr client)
396{
397    REQUEST(xRRSetPanningReq);
398
399    REQUEST_SIZE_MATCH(xRRSetPanningReq);
400    swaps(&stuff->length);
401    swapl(&stuff->crtc);
402    swapl(&stuff->timestamp);
403    swaps(&stuff->left);
404    swaps(&stuff->top);
405    swaps(&stuff->width);
406    swaps(&stuff->height);
407    swaps(&stuff->track_left);
408    swaps(&stuff->track_top);
409    swaps(&stuff->track_width);
410    swaps(&stuff->track_height);
411    swaps(&stuff->border_left);
412    swaps(&stuff->border_top);
413    swaps(&stuff->border_right);
414    swaps(&stuff->border_bottom);
415    return (*ProcRandrVector[stuff->randrReqType]) (client);
416}
417
418static int _X_COLD
419SProcRRSetOutputPrimary(ClientPtr client)
420{
421    REQUEST(xRRSetOutputPrimaryReq);
422
423    REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
424    swaps(&stuff->length);
425    swapl(&stuff->window);
426    swapl(&stuff->output);
427    return ProcRandrVector[stuff->randrReqType] (client);
428}
429
430static int _X_COLD
431SProcRRGetOutputPrimary(ClientPtr client)
432{
433    REQUEST(xRRGetOutputPrimaryReq);
434
435    REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
436    swaps(&stuff->length);
437    swapl(&stuff->window);
438    return ProcRandrVector[stuff->randrReqType] (client);
439}
440
441static int _X_COLD
442SProcRRGetProviders(ClientPtr client)
443{
444    REQUEST(xRRGetProvidersReq);
445
446    REQUEST_SIZE_MATCH(xRRGetProvidersReq);
447    swaps(&stuff->length);
448    swapl(&stuff->window);
449    return ProcRandrVector[stuff->randrReqType] (client);
450}
451
452static int _X_COLD
453SProcRRGetProviderInfo(ClientPtr client)
454{
455    REQUEST(xRRGetProviderInfoReq);
456
457    REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
458    swaps(&stuff->length);
459    swapl(&stuff->provider);
460    swapl(&stuff->configTimestamp);
461    return ProcRandrVector[stuff->randrReqType] (client);
462}
463
464static int _X_COLD
465SProcRRSetProviderOffloadSink(ClientPtr client)
466{
467    REQUEST(xRRSetProviderOffloadSinkReq);
468
469    REQUEST_SIZE_MATCH(xRRSetProviderOffloadSinkReq);
470    swaps(&stuff->length);
471    swapl(&stuff->provider);
472    swapl(&stuff->sink_provider);
473    swapl(&stuff->configTimestamp);
474    return ProcRandrVector[stuff->randrReqType] (client);
475}
476
477static int _X_COLD
478SProcRRSetProviderOutputSource(ClientPtr client)
479{
480    REQUEST(xRRSetProviderOutputSourceReq);
481
482    REQUEST_SIZE_MATCH(xRRSetProviderOutputSourceReq);
483    swaps(&stuff->length);
484    swapl(&stuff->provider);
485    swapl(&stuff->source_provider);
486    swapl(&stuff->configTimestamp);
487    return ProcRandrVector[stuff->randrReqType] (client);
488}
489
490static int _X_COLD
491SProcRRListProviderProperties(ClientPtr client)
492{
493    REQUEST(xRRListProviderPropertiesReq);
494
495    REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
496    swaps(&stuff->length);
497    swapl(&stuff->provider);
498    return ProcRandrVector[stuff->randrReqType] (client);
499}
500
501static int _X_COLD
502SProcRRQueryProviderProperty(ClientPtr client)
503{
504    REQUEST(xRRQueryProviderPropertyReq);
505
506    REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
507    swaps(&stuff->length);
508    swapl(&stuff->provider);
509    swapl(&stuff->property);
510    return ProcRandrVector[stuff->randrReqType] (client);
511}
512
513static int _X_COLD
514SProcRRConfigureProviderProperty(ClientPtr client)
515{
516    REQUEST(xRRConfigureProviderPropertyReq);
517
518    REQUEST_AT_LEAST_SIZE(xRRConfigureProviderPropertyReq);
519    swaps(&stuff->length);
520    swapl(&stuff->provider);
521    swapl(&stuff->property);
522    /* TODO: no way to specify format? */
523    SwapRestL(stuff);
524    return ProcRandrVector[stuff->randrReqType] (client);
525}
526
527static int _X_COLD
528SProcRRChangeProviderProperty(ClientPtr client)
529{
530    REQUEST(xRRChangeProviderPropertyReq);
531
532    REQUEST_AT_LEAST_SIZE(xRRChangeProviderPropertyReq);
533    swaps(&stuff->length);
534    swapl(&stuff->provider);
535    swapl(&stuff->property);
536    swapl(&stuff->type);
537    swapl(&stuff->nUnits);
538    switch (stuff->format) {
539    case 8:
540        break;
541    case 16:
542        SwapRestS(stuff);
543        break;
544    case 32:
545        SwapRestL(stuff);
546        break;
547    }
548    return ProcRandrVector[stuff->randrReqType] (client);
549}
550
551static int _X_COLD
552SProcRRDeleteProviderProperty(ClientPtr client)
553{
554    REQUEST(xRRDeleteProviderPropertyReq);
555
556    REQUEST_SIZE_MATCH(xRRDeleteProviderPropertyReq);
557    swaps(&stuff->length);
558    swapl(&stuff->provider);
559    swapl(&stuff->property);
560    return ProcRandrVector[stuff->randrReqType] (client);
561}
562
563static int _X_COLD
564SProcRRGetProviderProperty(ClientPtr client)
565{
566    REQUEST(xRRGetProviderPropertyReq);
567
568    REQUEST_SIZE_MATCH(xRRGetProviderPropertyReq);
569    swaps(&stuff->length);
570    swapl(&stuff->provider);
571    swapl(&stuff->property);
572    swapl(&stuff->type);
573    swapl(&stuff->longOffset);
574    swapl(&stuff->longLength);
575    return ProcRandrVector[stuff->randrReqType] (client);
576}
577
578static int _X_COLD
579SProcRRGetMonitors(ClientPtr client) {
580    REQUEST(xRRGetMonitorsReq);
581
582    REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
583    swaps(&stuff->length);
584    swapl(&stuff->window);
585    return ProcRandrVector[stuff->randrReqType] (client);
586}
587
588static int _X_COLD
589SProcRRSetMonitor(ClientPtr client) {
590    REQUEST(xRRSetMonitorReq);
591
592    REQUEST_AT_LEAST_SIZE(xRRGetMonitorsReq);
593    swaps(&stuff->length);
594    swapl(&stuff->window);
595    swapl(&stuff->monitor.name);
596    swaps(&stuff->monitor.noutput);
597    swaps(&stuff->monitor.x);
598    swaps(&stuff->monitor.y);
599    swaps(&stuff->monitor.width);
600    swaps(&stuff->monitor.height);
601    SwapRestL(stuff);
602    return ProcRandrVector[stuff->randrReqType] (client);
603}
604
605static int _X_COLD
606SProcRRDeleteMonitor(ClientPtr client) {
607    REQUEST(xRRDeleteMonitorReq);
608
609    REQUEST_SIZE_MATCH(xRRDeleteMonitorReq);
610    swaps(&stuff->length);
611    swapl(&stuff->window);
612    swapl(&stuff->name);
613    return ProcRandrVector[stuff->randrReqType] (client);
614}
615
616static int _X_COLD
617SProcRRCreateLease(ClientPtr client) {
618    REQUEST(xRRCreateLeaseReq);
619
620    REQUEST_AT_LEAST_SIZE(xRRCreateLeaseReq);
621    swaps(&stuff->length);
622    swapl(&stuff->window);
623    swaps(&stuff->nCrtcs);
624    swaps(&stuff->nOutputs);
625    SwapRestL(stuff);
626    return ProcRandrVector[stuff->randrReqType] (client);
627}
628
629static int _X_COLD
630SProcRRFreeLease(ClientPtr client) {
631    REQUEST(xRRFreeLeaseReq);
632
633    REQUEST_SIZE_MATCH(xRRFreeLeaseReq);
634    swaps(&stuff->length);
635    swapl(&stuff->lid);
636    return ProcRandrVector[stuff->randrReqType] (client);
637}
638
639int (*SProcRandrVector[RRNumberRequests]) (ClientPtr) = {
640    SProcRRQueryVersion,        /* 0 */
641/* we skip 1 to make old clients fail pretty immediately */
642        NULL,                   /* 1 SProcRandrOldGetScreenInfo */
643/* V1.0 apps share the same set screen config request id */
644        SProcRRSetScreenConfig, /* 2 */
645        NULL,                   /* 3 SProcRandrOldScreenChangeSelectInput */
646/* 3 used to be ScreenChangeSelectInput; deprecated */
647        SProcRRSelectInput,     /* 4 */
648        SProcRRGetScreenInfo,   /* 5 */
649/* V1.2 additions */
650        SProcRRGetScreenSizeRange,      /* 6 */
651        SProcRRSetScreenSize,   /* 7 */
652        SProcRRGetScreenResources,      /* 8 */
653        SProcRRGetOutputInfo,   /* 9 */
654        SProcRRListOutputProperties,    /* 10 */
655        SProcRRQueryOutputProperty,     /* 11 */
656        SProcRRConfigureOutputProperty, /* 12 */
657        SProcRRChangeOutputProperty,    /* 13 */
658        SProcRRDeleteOutputProperty,    /* 14 */
659        SProcRRGetOutputProperty,       /* 15 */
660        SProcRRCreateMode,      /* 16 */
661        SProcRRDestroyMode,     /* 17 */
662        SProcRRAddOutputMode,   /* 18 */
663        SProcRRDeleteOutputMode,        /* 19 */
664        SProcRRGetCrtcInfo,     /* 20 */
665        SProcRRSetCrtcConfig,   /* 21 */
666        SProcRRGetCrtcGammaSize,        /* 22 */
667        SProcRRGetCrtcGamma,    /* 23 */
668        SProcRRSetCrtcGamma,    /* 24 */
669/* V1.3 additions */
670        SProcRRGetScreenResources,      /* 25 GetScreenResourcesCurrent */
671        SProcRRSetCrtcTransform,        /* 26 */
672        SProcRRGetCrtcTransform,        /* 27 */
673        SProcRRGetPanning,      /* 28 */
674        SProcRRSetPanning,      /* 29 */
675        SProcRRSetOutputPrimary,        /* 30 */
676        SProcRRGetOutputPrimary,        /* 31 */
677/* V1.4 additions */
678        SProcRRGetProviders,            /* 32 */
679        SProcRRGetProviderInfo,         /* 33 */
680        SProcRRSetProviderOffloadSink,  /* 34 */
681        SProcRRSetProviderOutputSource, /* 35 */
682        SProcRRListProviderProperties,  /* 36 */
683        SProcRRQueryProviderProperty,   /* 37 */
684        SProcRRConfigureProviderProperty, /* 38 */
685        SProcRRChangeProviderProperty,  /* 39 */
686        SProcRRDeleteProviderProperty,  /* 40 */
687        SProcRRGetProviderProperty,     /* 41 */
688/* V1.5 additions */
689        SProcRRGetMonitors,            /* 42 */
690        SProcRRSetMonitor,             /* 43 */
691        SProcRRDeleteMonitor,          /* 44 */
692/* V1.6 additions */
693        SProcRRCreateLease,            /* 45 */
694        SProcRRFreeLease,              /* 46 */
695};
696