xf86vmode.c

远程桌面连接工具

    rep.length = (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xGenericReply) +
		  privsize * sizeof(INT32)) >> 2;
    rep.sequenceNumber = client->sequence;
    rep.dotclock = vptr->clock[mptr->Clock];
    rep.hdisplay = mptr->HDisplay;
    rep.hsyncstart = mptr->HSyncStart;
    rep.hsyncend = mptr->HSyncEnd;
    rep.htotal = mptr->HTotal;
    rep.vdisplay = mptr->VDisplay;
    rep.vsyncstart = mptr->VSyncStart;
    rep.vsyncend = mptr->VSyncEnd;
    rep.vtotal = mptr->VTotal;
    rep.flags = mptr->Flags;
    rep.privsize = privsize;
    if (client->swapped) {
    	swaps(&rep.sequenceNumber, n);
    	swapl(&rep.length, n);
	swapl(&rep.dotclock, n);
    	swaps(&rep.hdisplay, n);
    	swaps(&rep.hsyncstart, n);
    	swaps(&rep.hsyncend, n);
    	swaps(&rep.htotal, n);
    	swaps(&rep.vdisplay, n);
    	swaps(&rep.vsyncstart, n);
    	swaps(&rep.vsyncend, n);
    	swaps(&rep.vtotal, n);
	swapl(&rep.flags, n);
	swapl(&rep.privsize, n);
    }
    WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), (char *)&rep);
    if (privsize) {
	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
	WriteSwappedDataToClient(client, privsize * sizeof(INT32),
				 mptr->Private);
    }
    return (client->noClientException);
}

static int
ProcXF86VidModeGetAllModeLines(client)
    register ClientPtr client;
{
    REQUEST(xXF86VidModeGetAllModeLinesReq);
    xXF86VidModeGetAllModeLinesReply rep;
    xXF86VidModeModeInfo mdinf;
    register int n;
    ScrnInfoPtr vptr;
    DisplayModePtr mptr, curmptr;
    int privsize, modecount=1;
    int totalPrivSize = 0;

    if (stuff->screen > screenInfo.numScreens)
	return BadValue;

    vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
    curmptr = mptr = vptr->modes;

    totalPrivSize = mptr->Private ? mptr->PrivSize : 0;

    while (mptr->next != curmptr) {
	++modecount;
	mptr = mptr->next;
	if (mptr->Private)
	    totalPrivSize += mptr->PrivSize;
    }

    REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
    rep.type = X_Reply;
    rep.length = (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xGenericReply) +
		  modecount * sizeof(xXF86VidModeModeInfo) +
		  totalPrivSize * sizeof(INT32)) >> 2;
    rep.sequenceNumber = client->sequence;
    rep.modecount = modecount;
    if (client->swapped) {
    	swaps(&rep.sequenceNumber, n);
    	swapl(&rep.length, n);
	swapl(&rep.modecount, n);
    }
    WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), (char *)&rep);
    mptr = curmptr;
    do {
        if (!mptr->Private)
	    privsize = 0;
        else
	    privsize = mptr->PrivSize;

        mdinf.dotclock = vptr->clock[mptr->Clock];
        mdinf.hdisplay = mptr->HDisplay;
        mdinf.hsyncstart = mptr->HSyncStart;
        mdinf.hsyncend = mptr->HSyncEnd;
        mdinf.htotal = mptr->HTotal;
        mdinf.vdisplay = mptr->VDisplay;
        mdinf.vsyncstart = mptr->VSyncStart;
        mdinf.vsyncend = mptr->VSyncEnd;
        mdinf.vtotal = mptr->VTotal;
        mdinf.flags = mptr->Flags;
        mdinf.privsize = privsize;
        if (client->swapped) {
	    swapl(&mdinf.dotclock, n);
    	    swaps(&mdinf.hdisplay, n);
    	    swaps(&mdinf.hsyncstart, n);
    	    swaps(&mdinf.hsyncend, n);
    	    swaps(&mdinf.htotal, n);
    	    swaps(&mdinf.vdisplay, n);
    	    swaps(&mdinf.vsyncstart, n);
    	    swaps(&mdinf.vsyncend, n);
    	    swaps(&mdinf.vtotal, n);
	    swapl(&mdinf.flags, n);
	    swapl(&mdinf.privsize, n);
        }
        WriteToClient(client, sizeof(xXF86VidModeModeInfo), (char *)&mdinf);
	if (privsize) {
	    client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
	    WriteSwappedDataToClient(client, privsize * sizeof(INT32),
				     mptr->Private);
	}
        mptr = mptr->next;
    } while (mptr != curmptr);
    return (client->noClientException);
}

#define CLOCKSPD(clk,scrp)	((clk>MAXCLOCKS)? clk: scrp->clock[clk])
#define MODEMATCH(mptr,stuff,scrp)	\
	(CLOCKSPD(mptr->Clock,scrp) == CLOCKSPD(stuff->dotclock,scrp) \
				&& mptr->HDisplay  == stuff->hdisplay \
				&& mptr->HSyncStart== stuff->hsyncstart \
				&& mptr->HSyncEnd  == stuff->hsyncend \
				&& mptr->HTotal    == stuff->htotal \
				&& mptr->VDisplay  == stuff->vdisplay \
				&& mptr->VSyncStart== stuff->vsyncstart \
				&& mptr->VSyncEnd  == stuff->vsyncend \
				&& mptr->VTotal    == stuff->vtotal \
				&& mptr->Flags     == stuff->flags )

#include "xf86_Config.h"

static int
ProcXF86VidModeAddModeLine(client)
    register ClientPtr client;
{
    REQUEST(xXF86VidModeAddModeLineReq);
    ScrnInfoPtr vptr;
    DisplayModePtr curmptr, mptr, newmptr;
    Bool clock_added = FALSE;
    int i, len;

    if (xf86Verbose > 1) {
	ErrorF("AddModeLine - scrn: %d clock: %d\n",
		stuff->screen, stuff->dotclock);
	ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
		stuff->hdisplay, stuff->hsyncstart,
		stuff->hsyncend, stuff->htotal);
	ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
		stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
		stuff->vtotal, stuff->flags);
	ErrorF("      after - scrn: %d clock: %d\n",
		stuff->screen, stuff->after_dotclock);
	ErrorF("              hdsp: %d hbeg: %d hend: %d httl: %d\n",
		stuff->after_hdisplay, stuff->after_hsyncstart,
		stuff->after_hsyncend, stuff->after_htotal);
	ErrorF("              vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
		stuff->after_vdisplay, stuff->after_vsyncstart,
		stuff->after_vsyncend, stuff->after_vtotal, stuff->after_flags);
    }
    if (stuff->screen > screenInfo.numScreens)
	return BadValue;

    vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
    curmptr = mptr = vptr->modes;

    REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq);
    len = client->req_len - (sizeof(xXF86VidModeAddModeLineReq) >> 2);
    if (len != stuff->privsize)
	return BadLength;

    if (stuff->hsyncstart < stuff->hdisplay   ||
	stuff->hsyncend   < stuff->hsyncstart ||
	stuff->htotal     < stuff->hsyncend   ||
	stuff->vsyncstart < stuff->vdisplay   ||
	stuff->vsyncend   < stuff->vsyncstart ||
	stuff->vtotal     < stuff->vsyncend)
	return BadValue;

    if (stuff->after_hsyncstart < stuff->after_hdisplay   ||
	stuff->after_hsyncend   < stuff->after_hsyncstart ||
	stuff->after_htotal     < stuff->after_hsyncend   ||
	stuff->after_vsyncstart < stuff->after_vdisplay   ||
	stuff->after_vsyncend   < stuff->after_vsyncstart ||
	stuff->after_vtotal     < stuff->after_vsyncend)
	return BadValue;

    if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
	Bool found = FALSE;
	do {
	    if (MODEMATCH(mptr, stuff, vptr)) {
		found = TRUE;
		break;
	    }
	} while ((mptr = mptr->next) != curmptr);
	if (!found)
	    return BadValue;
    }

    newmptr = (DisplayModePtr) xalloc(sizeof(DisplayModeRec));

    /* Clock checking code, mostly copied from the xf86LookupMode function */
    if (stuff->dotclock < vptr->clocks) {
	newmptr->Clock = stuff->dotclock;
    } else {
	if ((OFLG_ISSET(CLOCK_OPTION_PROGRAMABLE, &(vptr->clockOptions))) &&
	    !OFLG_ISSET(OPTION_NO_PROGRAM_CLOCKS, &(vptr->options)))
	{
	    for (i = 0; i < vptr->clocks; i++)
		if (stuff->dotclock == vptr->clock[i])
		    break;

	    if (i >= MAXCLOCKS || vptr->clock[i]/1000 > vptr->maxClock/1000) {
		xfree(newmptr);
		return vidmodeErrorBase + XF86VidModeBadClock;
	    }
	
	    if (i == vptr->clocks) {
		vptr->clock[i] = stuff->dotclock;
		vptr->clocks++;
		clock_added = TRUE;
	    }
	} else {
	    int		flags=0, j, k, Gap, Minimum_Gap = CLOCK_TOLERANCE + 1;
	    double	refresh, bestRefresh = 0.0;

	    if (OFLG_ISSET(OPTION_CLKDIV2, &(vptr->options)))
	        k=2;
	    else
	        k=1;
	    
	    if (xf86BestRefresh)
	    	flags |= LOOKUP_BEST_REFRESH;

	    for (j=1 ; j<=k ; j++) {
	        i = xf86GetNearestClock(vptr, stuff->dotclock * j);
	        if (flags & LOOKUP_BEST_REFRESH) {
		    if ( ((vptr->clock[i]/j) / 1000) > (vptr->maxClock / 1000) ) {
			xfree(newmptr);
			return vidmodeErrorBase + XF86VidModeBadClock;
		    } else {
		        refresh = stuff->dotclock * 1000.0 / stuff->htotal / stuff->vtotal;
		        if (stuff->flags & V_INTERLACE) {
			    refresh *= 2;
			    refresh /= INTERLACE_REFRESH_WEIGHT;
			} else if (stuff->flags & V_DBLSCAN)
			    refresh /= 2;

		        if (refresh > bestRefresh) {
			    newmptr->Clock = i;
			    if (j==2) stuff->flags |= V_CLKDIV2;
			    bestRefresh = refresh;
		        }
		    }
		} else {
		    Gap = abs( stuff->dotclock - (vptr->clock[i]/j) );
		    if (Gap < Minimum_Gap) {
			if ( ((vptr->clock[i]/j) / 1000) > (vptr->maxClock / 1000) ) {
			    xfree(newmptr);
			    return vidmodeErrorBase + XF86VidModeBadClock;
			} else {
			    newmptr->Clock = i;
			    if (j==2) stuff->flags |= V_CLKDIV2;
			    Minimum_Gap = Gap;
		        }
		    }
	        }
	    }
	}
    }

    newmptr->CrtcHDisplay  = newmptr->HDisplay      = stuff->hdisplay;
    newmptr->CrtcHSyncStart= newmptr->HSyncStart    = stuff->hsyncstart;
    newmptr->CrtcHSyncEnd  = newmptr->HSyncEnd      = stuff->hsyncend;
    newmptr->CrtcHTotal    = newmptr->HTotal        = stuff->htotal;
    newmptr->CrtcVDisplay  = newmptr->VDisplay      = stuff->vdisplay;
    newmptr->CrtcVSyncStart= newmptr->VSyncStart    = stuff->vsyncstart;
    newmptr->CrtcVSyncEnd  = newmptr->VSyncEnd      = stuff->vsyncend;
    newmptr->CrtcVTotal    = newmptr->VTotal        = stuff->vtotal;
    newmptr->Flags         = stuff->flags;
#if 0
    newmptr->CrtcHSkew     = newmptr->HSkew         = stuff->hskew;
#endif
    newmptr->CrtcHAdjusted = FALSE;
    newmptr->CrtcVAdjusted = FALSE;
    newmptr->name          = "";
    newmptr->Private       = NULL;
    if (stuff->privsize) {
	if (xf86Verbose > 1)
	    ErrorF("AddModeLine - Request includes privates\n");
	newmptr->Private =
	    (INT32 *) ALLOCATE_LOCAL(stuff->privsize * sizeof(INT32));
	memcpy(newmptr->Private, &stuff[1], stuff->privsize*sizeof(INT32));
    }

    /* Check that the mode is consistent with the monitor specs */
    switch (xf86CheckMode(vptr, newmptr, vptr->monitor, FALSE)) {
    	case MODE_OK:
	    break;
	case MODE_HSYNC:
	    xfree(newmptr->Private);
	    xfree(newmptr);
	    if (clock_added)
	    	vptr->clocks--;
	    return vidmodeErrorBase + XF86VidModeBadHTimings;
	case MODE_VSYNC:
	    xfree(newmptr->Private);
	    xfree(newmptr);
	    if (clock_added)
	    	vptr->clocks--;
	    return vidmodeErrorBase + XF86VidModeBadVTimings;
	default:
	    if (clock_added)
	    	vptr->clocks--;
	    return vidmodeErrorBase + XF86VidModeModeUnsuitable;
    }

    /* Check that the driver is happy with the mode */
    if (vptr->ValidMode(newmptr, xf86Verbose, MODE_VID) != MODE_OK) {
	xfree(newmptr->Private);
	xfree(newmptr);
	if (clock_added)
	    vptr->clocks--;
	return vidmodeErrorBase + XF86VidModeModeUnsuitable;
    }

    if (newmptr->Flags & V_DBLSCAN)
    {
	newmptr->CrtcVDisplay *= 2;
	newmptr->CrtcVSyncStart *= 2;
	newmptr->CrtcVSyncEnd *= 2;
	newmptr->CrtcVTotal *= 2;
	newmptr->CrtcVAdjusted = TRUE;
    }

    newmptr->next       = mptr->next;
    newmptr->prev       = mptr;
    mptr->next          = newmptr;
    newmptr->next->prev = newmptr;

#if 0  /* Do we want this? */
    (vptr->SwitchMode)(newmptr);
#endif

    if (xf86Verbose > 1)
	ErrorF("AddModeLine - Succeeded\n");
    return(client->noClientException);
}

static int
ProcXF86VidModeDeleteModeLine(client)
    register ClientPtr client;
{
    REQUEST(xXF86VidModeDeleteModeLineReq);
    ScrnInfoPtr vptr;
    DisplayModePtr curmptr, mptr;
    int len;

    if (xf86Verbose > 1) {
	ErrorF("DeleteModeLine - scrn: %d clock: %d\n",
		stuff->screen, stuff->dotclock, stuff->dotclock);
	ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
		stuff->hdisplay, stuff->hsyncstart,
		stuff->hsyncend, stuff->htotal);
	ErrorF("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
		stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
		stuff->vtotal, stuff->flags);
    }
    if (stuff->screen > screenInfo.numScreens)
	return BadValue;

    vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
    curmptr = mptr = vptr->modes;

    REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq);
    len = client->req_len - (sizeof(xXF86VidModeDeleteModeLineReq) >> 2);
    if (len != stuff->privsize) {
	if (xf86Verbose > 1) {
	    ErrorF("req_len = %d, sizeof(Req) = %d, privsize = %d, len = %d, length = %d\n",
		    client->req_len, sizeof(xXF86VidModeDeleteModeLineReq)>>2, stuff->privsize, len, stuff->length);
	}
	return BadLength;
    }
    if (xf86Verbose > 1) {
	ErrorF("Checking against clock: %d (%d)\n",
		mptr->Clock, CLOCKSPD(mptr->Clock, vptr));
	ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
		mptr->HDisplay, mptr->HSyncStart,
		mptr->HSyncEnd, mptr->HTotal);
	ErrorF("                 vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
		mptr->VDisplay, mptr->VSyncStart, mptr->VSyncEnd,
		mptr->VTotal, mptr->Flags);
    }
    if (MODEMATCH(mptr, stuff, vptr))
	return BadValue;

    while ((mptr = mptr->next) != curmptr) {
	if (xf86Verbose > 1) {
	    ErrorF("Checking against clock: %d (%d)\n",
		    mptr->Clock, CLOCKSPD(mptr->Clock, vptr));