windows-server-2003/multimedia/directx/dinput/dx7/dll/dieff.c

/*****************************************************************************
 *
 *  DIEff.c
 *
 *  Copyright (c) 1996 Microsoft Corporation.  All Rights Reserved.
 *
 *  Abstract:
 *
 *      The standard implementation of IDirectInputEffect.
 *
 *      This is the device-independent part.  the device-dependent
 *      part is handled by the IDirectInputEffectShepherd.
 *
 *  Contents:
 *
 *      CDIEff_CreateInstance
 *
 *****************************************************************************/

#include "dinputpr.h"

#ifdef IDirectInputDevice2Vtbl

/*****************************************************************************
 *
 *      Note!
 *
 *      Out of laziness, all effects share the same critical section as
 *      their parent device.  This saves us from all sorts of race
 *      conditions.  Not all of them, but a big chunk of them.
 *
 *      A common race condition that this protects us against is
 *      where an application tries to download an effect at the same
 *      time another thread decides to unacquire the device.
 *
 *****************************************************************************/

/*****************************************************************************
 *
 *      More laziness:  "TypeSpecificParams" is such a long thing.
 *
 *****************************************************************************/

#define cbTSP       cbTypeSpecificParams
#define lpvTSP      lpvTypeSpecificParams

/*****************************************************************************
 *
 *      The sqiffle for this file.
 *
 *****************************************************************************/

#define sqfl sqflEff

/*****************************************************************************
 *
 *    The flags for dwMessage
 *
 *****************************************************************************/
#define EFF_DEFAULT 0
#define EFF_PLAY    1
#define EFF_STOP    2

/*****************************************************************************
 *
 *      Declare the interfaces we will be providing.
 *
 *****************************************************************************/

Primary_Interface(CDIEff, IDirectInputEffect);

Interface_Template_Begin(CDIEff)
    Primary_Interface_Template(CDIEff, IDirectInputEffect)
Interface_Template_End(CDIEff)

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @struct CDIEff |
 *
 *          The generic <i IDirectInputEffect> object.
 *
 *  @field  IDirectInputEffect | def |
 *
 *          <i DirectInputEffect> object (containing vtbl).
 *
 *  @field  struct CDIDev * | pdev |
 *
 *          Reference to parent device tracked via <f Common_Hold>.
 *
 *  @field  DICREATEEFFECTINFO | cei |
 *
 *          Parameters that tell us how to talk to the effect driver.
 *
 *  @field  BOOL | fInitialized:1 |
 *
 *          Do we know who we are?
 *
 *  @field  BOOL | fDadNotified:1 |
 *
 *          Does our parent know that we exist?
 *
 *  @field  BOOL | fDadDead:1 |
 *
 *          Has our parent been destroyed (from the app's point of view)?
 *
 *  @field  TSDPROC | hresValidTsd |
 *
 *          Callback function that validates the type-specific data.
 *
 *  @field  DIEFFECTATTRIBUTES | dEffAttributes |
 *
 *         Attributes of the effect (includes dwEffectType and dwEffectId, among others).
 *
 *  @field  HANDLE | hEventDelete |
 *
 *          Event to signal to the timer thread that the app performed final release on the effect.
 *
 *  @field  HANDLE | hEventThreadDead |
 *
 *          Event to signal AppFinalize to perform the final release on the effect.
 *
 *  @field  HANDLE | hEventGeneral |
 *
 *          Event to signal to the timer thread that the app called Start(...) or Stop() the effect.
 *
 *  @field  DWORD | dwMessage |
 *
 *			Message to the thread as to which event hEventGeneral is actually signaling.
 *			Can be EFF_DEFAULT, EFF_PLAY or EFF_STOP>
 *
 *  @field  DWORD | dwcLoop|
 *
 *			Loop count for playing the effect (passed in the call to Start(...))
 *
 *  @field  DWORD | dwFlags |
 *
 *          Flags for playing the effect (passed in the call to Start(...))
 *
 *  @field  DWORD | diepDirty |
 *
 *          The parts of the effect which are "dirty" and need to
 *          be updated by the next <mf IDirectInputEffect::Download>.
 *
 *  @field  DWORD | diepUnset |
 *
 *          The parts of the effect which have yet to be set by the
 *          application.  Items which we can set decent defaults for
 *          are not counted.
 *
 *  @field  DWORD | dwDirFlags |
 *
 *          Flags that record the direction format the application
 *          last set.
 *
 *  @field  DWORD | dwCoords |
 *
 *          Coordinate systems supported by device.
 *
 *  @field  LPVOID | lpvTSP |
 *
 *          Temporary buffer used to cache type-specific parameters
 *          during Try'ing of proposed effect parameters.
 *
 *  @field  SHEPHANDLE | sh |
 *
 *          Effect handle information.
 *
 *  @field  DIEFFECT | eff |
 *
 *          Cached effect parameters as they exist (or should exist)
 *          on the device.
 *          Direction parameters are in device-preferred coordinates.
 *
 *  @field  DIENVELOPE | env |
 *
 *          Cached envelope parameters as they exist (or should exist)
 *          on the device.
 *
 *  @field  LONG | rglDirApp[DIEFFECT_MAXAXES] |
 *
 *          Cached direction list, in application native format.
 *          The format of this array is kept in the
 *          <e CDIEff.dwDirFlags> field.
 *
 *  @field  DWORD | rgdwAxes[DIEFFECT_MAXAXES] |
 *
 *          Cached axis list, stored as item numbers.
 *
 *  @field  LONG | rglDirDev[DIEFFECT_MAXAXES] |
 *
 *          Cached direction list, in device native format.
 *          The format of this array is kept in the
 *          <e DIEFFECT.dwFlags> field of the
 *          <e CDIEff.eff>.
 *
 *  @field  GUID | guid |
 *
 *          Identity.
 *
 *****************************************************************************/

typedef STDMETHOD(TSDPROC)(LPCDIEFFECT peff, DWORD cAxes);

typedef struct CDIEff {

    /* Supported interfaces */
    IDirectInputEffect def;

    struct CDIDev *pdev;
    LPDIRECTINPUTEFFECTSHEPHERD pes;

    BOOL fDadNotified:1;
    BOOL fDadDead:1;
    BOOL fInitialized:1;

    TSDPROC hresValidTsd;

    /* WARNING!  EVERYTHING AFTER THIS LINE IS ZERO'd ON A RESET */

	DIEFFECTATTRIBUTES dEffAttributes;
	HANDLE hEventDelete;
	HANDLE hEventGeneral;
    HANDLE hEventThreadDead;
	DWORD dwMessage;

	DWORD dwcLoop;
	DWORD dwFlags;

    DWORD diepDirty;
    DWORD diepUnset;
    DWORD dwDirFlags;
    DWORD dwCoords;
    LPVOID lpvTSP;
    SHEPHANDLE sh;

    DIEFFECT effDev;
    DIEFFECT effTry;
    DIENVELOPE env;

    GUID guid;

    LONG rglDirApp[DIEFFECT_MAXAXES];
    DWORD rgdwAxes[DIEFFECT_MAXAXES];
    LONG rglDirDev[DIEFFECT_MAXAXES];
    LONG rglDirTry[DIEFFECT_MAXAXES];

    /* WARNING!  EVERYTHING ABOVE THIS LINE IS ZERO'd ON A RESET */

    /*
     *  The Reset() function assumes that the entire remainder
     *  of the structure is to be zero'd out, so if you add a field
     *  here, make sure to adjust Reset() accordingly.
     */

} CDIEff, DE, *PDE;

#define ThisClass CDIEff
#define ThisInterface IDirectInputEffect

/*****************************************************************************
 *
 *      Forward declarations
 *
 *      These are out of laziness, not out of necessity.
 *
 *****************************************************************************/

STDMETHODIMP CDIEff_IsValidUnknownTsd(LPCDIEFFECT peff, DWORD cAxes);

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | QueryInterface |
 *
 *          Gives a client access to other interfaces on an object.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   IN REFIID | riid |
 *
 *          The requested interface's IID.
 *
 *  @parm   OUT LPVOID * | ppvObj |
 *
 *          Receives a pointer to the obtained interface.
 *
 *  @returns
 *
 *          Returns a COM error code.
 *
 *  @xref   OLE documentation for <mf IUnknown::QueryInterface>.
 *
 *****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | AddRef |
 *
 *          Increments the reference count for the interface.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @returns
 *
 *          Returns the object reference count.
 *
 *  @xref   OLE documentation for <mf IUnknown::AddRef>.
 *
 *****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Release |
 *
 *          Decrements the reference count for the interface.
 *          If the reference count on the object falls to zero,
 *          the object is freed from memory.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @returns
 *
 *          Returns the object reference count.
 *
 *  @xref   OLE documentation for <mf IUnknown::Release>.
 *
 *****************************************************************************/

#ifdef DEBUG

Default_QueryInterface(CDIEff)
Default_AddRef(CDIEff)
Default_Release(CDIEff)

#else

#define CDIEff_QueryInterface           Common_QueryInterface
#define CDIEff_AddRef                   Common_AddRef
#define CDIEff_Release                  Common_Release
#endif

#define CDIEff_QIHelper                 Common_QIHelper

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method void | CDIEff | EnterCrit |
 *
 *          Enter the object critical section.
 *
 *  @cwrap  PDE | this
 *
 *****************************************************************************/

void INLINE  
CDIEff_EnterCrit(PDE this)
{
    AssertF(this->pdev);
    CDIDev_EnterCrit(this->pdev);
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method void | CDIEff | LeaveCrit |
 *
 *          Leave the object critical section.
 *
 *  @cwrap  PDE | this
 *
 *****************************************************************************/

void INLINE
CDIEff_LeaveCrit(PDE this)
{
    AssertF(this->pdev);
    CDIDev_LeaveCrit(this->pdev);
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method void | CDIEff | CanAccess |
 *
 *          Check if the effect can be accessed.  For this to succeeed,
 *          the effect must be initialized, and the parent device
 *          must be acquired in exclusive mode.
 *
 *  @cwrap  PDE | this
 *
 *  @returns
 *
 *          <c S_OK> if the device is exclusively acquired.
 *
 *          <c DIERR_INPUTLOST> if acquisition has been lost.
 *
 *          <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
 *          but not exclusively, or if the device is not acquired
 *          at all.
 *
 *          <c DIERR_NOTINITIALIZED> if the effect object has not
 *          yet been initialized.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_CanAccess_(this, z)                                  \
       _CDIEff_CanAccess_(this)                                     \

#endif

STDMETHODIMP
CDIEff_CanAccess_(PDE this, LPCSTR s_szProc)
{
    HRESULT hres;

    AssertF(this->pdev);
    AssertF(CDIDev_InCrit(this->pdev));

    if (this->fInitialized) {
        hres = CDIDev_IsExclAcquired(this->pdev);
    } else {
        if (s_szProc) {
            RPF("ERROR %s: Effect not initialized", s_szProc);
        }
        hres = DIERR_NOTINITIALIZED;
    }

    return hres;
}

#define CDIEff_CanAccess(this)                                      \
        CDIEff_CanAccess_(this, s_szProc)                           \

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_Reset |
 *
 *          Releases all the resources of a generic effect that
 *          are associated with a particular device effect instance.
 *
 *          This method is called in preparation for reinitialization.
 *
 *  @parm   PV | pvObj |
 *
 *          Object being reset.  Note that it may not have been
 *          completely initialized, so everything should be done
 *          carefully.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Reset(PDE this)
{
	HRESULT hres;

    AssertF(this->pdev);
    CDIEff_EnterCrit(this);

    /*
     *  Destroying an effect implicitly stops it.
     *
     *  It's okay if this fails (and in fact it usually will).
     *  We're just playing it safe.
     */
    hres = IDirectInputEffectShepherd_DestroyEffect(this->pes, &this->sh);

    AssertF(this->lpvTSP == 0);
    FreePpv(&this->effDev.lpvTSP);

	//rezero the entire DIEFFECTATTRIBUTES!
	ZeroBuf(&this->dEffAttributes, 
                         cbX(DE) -
                         FIELD_OFFSET(DE, dEffAttributes));


	//rezero effect's event handles
	if (this->hEventDelete != NULL)
	{
		CloseHandle(this->hEventDelete);
		this->hEventDelete = NULL;
	}

	if (this->hEventGeneral != NULL)
	{
		CloseHandle(this->hEventGeneral);
		this->hEventGeneral = NULL;
	}
	
	if (this->hEventThreadDead != NULL)
	{
		CloseHandle(this->hEventThreadDead);
		this->hEventThreadDead = NULL;
	}

	this->dwMessage = EFF_DEFAULT;

    this->effDev.dwSize = cbX(this->effDev);
    this->env.dwSize = cbX(this->env);

    /*
     *  DIEP_DURATION               - Defaults to zero.
     *  DIEP_SAMPLEPERIOD           - Defaults to zero.
     *  DIEP_GAIN                   - Defaults to zero.
     *  DIEP_TRIGGERBUTTON          - Defaults to DIEB_NOTRIGGER.
     *  DIEP_TRIGGERREPEATINTERVAL  - Defaults to INFINITE (no autorepeat).
     *  DIEP_AXES                   - Must be set manually.
     *  DIEP_DIRECTION              - Must be set manually.
     *  DIEP_ENVELOPE               - No envelope.
     *  DIEP_TYPESPECIFICPARAMS     - Must be set manually.
#if DIRECTINPUT_VERSION >= 0x0600
     *  DIEP_STARTDELAY             - Defaults to zero.
#endif
     */

    this->effDev.dwTriggerButton = DIEB_NOTRIGGER;

    this->diepUnset = DIEP_AXES |
                      DIEP_DIRECTION |
                      DIEP_TYPESPECIFICPARAMS;

    this->effDev.rgdwAxes = this->rgdwAxes;
    this->effDev.rglDirection = this->rglDirDev;

    this->fInitialized = 0;

    CDIEff_LeaveCrit(this);

    hres = S_OK;

    return hres;


}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | UnloadWorker |
 *
 *          Remove the effect from the device.  All parameters have
 *          been validated.
 *
 *  @cwrap  PDE | this
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c S_FALSE>: The effect was not previously downloaded,
 *          so there was nothing to unload.  Note that this is a
 *          success code.
 *
 *          <c DI_PROPNOEFFECT> = <c S_FALSE>: The effect was not
 *          previously downloaded.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *          <c DIERR_INPUTLOST> if acquisition has been lost.
 *
 *          <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
 *          but not exclusively, or if the device is not acquired
 *          at all.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_UnloadWorker_(this, z)                               \
       _CDIEff_UnloadWorker_(this)                                  \

#endif

HRESULT INTERNAL
CDIEff_UnloadWorker_(PDE this, LPCSTR s_szProc)
{

	HRESULT hres;

    AssertF(CDIDev_InCrit(this->pdev));

    if (SUCCEEDED(hres = CDIEff_CanAccess(this))) {
        /*
         *  The effect driver will stop the effect (if it is playing)
         *  before destroying it.
         */
            hres = IDirectInputEffectShepherd_DestroyEffect(
                        this->pes, &this->sh);
    } else {
        /*
         *  The effect is dead.  Long live the effect.
         */
        this->sh.dwEffect = 0;
    }

    this->diepDirty = DIEP_ALLPARAMS;

    return hres;

}

#define CDIEff_UnloadWorker(this)                                   \
        CDIEff_UnloadWorker_(this, s_szProc)                        \

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   void | CDIEff_AppFinalize |
 *
 *          The application has performed its final release.
 *
 *          Tell our parent that we are officially dead, so that
 *          dad will stop tracking us and release its hold on us.
 *
 *  @parm   PV | pvObj |
 *
 *          Object being released.  Note that it may not have been
 *          completely initialized, so everything should be done
 *          carefully.
 *
 *****************************************************************************/

void INTERNAL
CDIEff_AppFinalize(PV pvObj)
{
    PDE this = pvObj;
    DWORD dwRc = 0xFFFFFFFF;

    EnterProcR(CDIEff_AppFinalize, (_ "p", pvObj));

    if (this->fDadNotified) {
        this->fDadNotified = 0;

        CDIEff_EnterCrit(this);

		/*
		 * Kill the timer thread, if any.
		 * For this, fire off the effect's event.
		 */
		
		if (this->hEventDelete != NULL) {
            if( SetEvent(this->hEventDelete) && this->hEventThreadDead != NULL ) 
            {
                do
                {
                    dwRc = WaitForSingleObject(this->hEventThreadDead, INFINITE);
                } while( dwRc != WAIT_OBJECT_0 );
                
                CloseHandle(this->hEventThreadDead);
                this->hEventThreadDead = NULL;
            }
        }

        CDIEff_UnloadWorker_(this, 0);
        CDIEff_LeaveCrit(this);
        CDIDev_NotifyDestroyEffect(this->pdev, this);
    }

    ExitProcR();
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   void | CDIEff_Finalize |
 *
 *          Releases the resources of an effect.
 *
 *  @parm   PV | pvObj |
 *
 *          Object being released.  Note that it may not have been
 *          completely initialized, so everything should be done
 *          carefully.
 *
 *****************************************************************************/

void INTERNAL
CDIEff_Finalize(PV pvObj)
{
    HRESULT hres;
    PDE this = pvObj;

#if 0 // def XDEBUG
    if (this->cCrit) {
        RPF("IDirectInputEffect::Release: Another thread is using the object; crash soon!");
    }
#endif

    AssertF(this->sh.dwEffect == 0);

    if (this->pdev) {
        hres = CDIEff_Reset(this);
        AssertF(SUCCEEDED(hres));
    }

    Invoke_Release(&this->pes);
    Common_Unhold(this->pdev);

}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | GetEffectGuid |
 *
 *          Retrieve the GUID for the effect represented by the
 *          <i IDirectInputEffect> object.  Additional information
 *          about the effect can be obtained by passing the
 *          <t GUID> to <mf IDirectInputDevice2::GetEffectInfo>.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   OUT LPGUID | pguid |
 *
 *          Points to a <t GUID> structure that is filled in
 *          by the function.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  The
 *          <p lpDirectInputEffect> or
 *          <p lpdc> parameter is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_GetEffectGuid(PDIE pdie, LPGUID pguid)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::GetEffectGuid, (_ "p", pdie));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresFullValidWritePguid(pguid, 1))) {
        PDE this = _thisPvNm(pdie, def);

        /*
         *  Race condition:  If the caller reinitializes and
         *  does a GetEffectGuid simultaneously, the return value
         *  is random.  That's okay; it's the caller's problem.
         */
        if (this->fInitialized) {
            *pguid = this->guid;
            hres = S_OK;
        } else {
            hres = DIERR_NOTINITIALIZED;
        }

    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   __int64 | _ftol |
 *
 *          Convert a floating point number to an integer.
 *
 *          We do it ourselves because the C runtime has been known to do a 
 *          poor job of this.
 *
 *          It's the caller's job to worry about the rounding mode.
 *
 *  @parm   double | lf |
 *
 *          Floating point number to convert.
 *
 *****************************************************************************/

#if defined(WIN95)

#pragma warning(disable:4035)           /* no return value (duh) */

BYTE _fltused;

__declspec(naked) __int64 __cdecl
_ftol(double lf)
{
    lf;
    _asm {
        sub     esp, 8
        fistp   qword ptr [esp]
        pop     eax
        pop     edx
        ret
    }
}

#pragma warning(default:4035)

#endif

/*
 *  The floating point type we use for intermediates.
 */
typedef long double FPTYPE;

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   FPTYPE | CDIEff_IntToAngle |
 *
 *          Convert an integer angle to a floating point angle.
 *
 *  @parm   LONG | l |
 *
 *          Integer angle to convert.
 *
 *****************************************************************************/

#ifndef M_PI
#define M_PI 3.1415926535897932384
#endif

FPTYPE INLINE
CDIEff_IntToAngle(LONG l)
{
    FPTYPE theta;

    /*
     *  2pi radians equals 360 degrees.
     */
    theta = l * (2 * M_PI) / (360 * DI_DEGREES);

    return theta;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   LONG | CDIEff_IntAtan2 |
 *
 *          Compute the floating point arctangent of y/x and
 *          convert the resulting angle to an integer in DI_DEGREES.
 *
 *  @parm   FPTYPE | y |
 *
 *          Vertical coordinate.
 *
 *  @parm   FPTYPE | x |
 *
 *          Horizontal coordinate.
 *
 *  @returns
 *
 *          A value in the range [ 0 .. 360 * DI_DEGREES ).
 *
 *****************************************************************************/

LONG INLINE
CDIEff_IntAtan2(FPTYPE y, FPTYPE x)
{
    FPTYPE theta;
    LONG l;

#if defined(_X86_)
    /*
     *  The Intel FPU doesn't care about (0, 0).
     */
    theta = atan2(y, x);
#else
    /*
     *  The Alpha gets really upset about (0, 0).
     */
    if (y != 0.0 || x != 0.0) {
        theta = atan2(y, x);
    } else {
        theta = 0.0;
    }
#endif

    /*
     *  atan2 returns a value in the range -M_PI to +M_PI.
     *  On the Intel x86, there are four rounding modes:
     *
     *      Round to nearest or even
     *      Round towards minus infinity
     *      Round towards plus infinity
     *      Round towards zero
     *
     *  By ensuring that the value being rounded is positive, we
     *  reduce to three cases:
     *
     *      Round to nearest or even
     *      Round down
     *      Round up
     *
     *  And as long as the app doesn't change its rounding mode
     *  (few do), the values will be consistent.  (Whereas if we
     *  let negative numbers through, you would get weird behavior
     *  as the angle neared M_PI aka -M_PI.)
     *
     *  Method 1:
     *
     *      if (theta < 0) theta += 2 * M_PI;
     *      l = convert(theta);
     *      return l;
     *
     *  This is bad because if theta starts out as -epsilon, then
     *  we end up converting 2 * M_PI - epsilon, which might get
     *  rounded up to 360 * DI_DEGREES.  But our return value
     *  must be in the range 0 <= l < 360 * DI_DEGREES.
     *
     *  So instead, we use method 2:
     *
     *  l = convert(theta + 2 * M_PI);
     *  if (l >= 360 * DI_DEGREES) l -= 360 * DI_DEGREES;
     *
     *  The value being converted ends up in the range M_PI .. 3 * M_PI,
     *  which after rounding becomes 180 * DI_DEGREES .. 540 * DI_DEGREES.
     *  The final check then pulls the value into range.
     */

    /*
     *  2pi radians equals 360 degrees.
     */
    l = (LONG)((theta + 2 * M_PI) * (360 * DI_DEGREES) / (2 * M_PI));
    if (l >= 360 * DI_DEGREES) {
        l -= 360 * DI_DEGREES;
    }

    return l;

}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   FPTYPE | atan2Z |
 *
 *          Just like <f atan2>, except it doesn't barf on
 *          (0, 0).
 *
 *  @parm   FPTYPE | y |
 *
 *          Vertical coordinate.
 *
 *  @parm   FPTYPE | x |
 *
 *          Horizontal coordinate.
 *
 *****************************************************************************/

FPTYPE INLINE
atan2Z(FPTYPE y, FPTYPE x)
{

#if defined(_X86_)
    /*
     *  The Intel FPU doesn't care about (0, 0).
     */
    return atan2(y, x);
#else
    /*
     *  The Alpha gets really upset about (0, 0).
     */
    if (y != 0.0 || x != 0.0) {
        return atan2(y, x);
    } else {
        return 0.0;
    }
#endif
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_CartToAngles |
 *
 *          Convert cartesian coordinates to angle-based coordinates
 *          (either polar or spherical).  Note that the resulting
 *          angles have not been normalized.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes involved, never zero.
 *
 *  @parm   LPLONG | rglAngles |
 *
 *          Buffer to receive angle-base coordinates.
 *          The final entry of the array contains nothing of interest.
 *
 *  @parm   LPCLONG | rglCart |
 *
 *          Buffer containing existing cartesian coordinates.
 *
 *  @parm   DWORD | dieff |
 *
 *          Flags specifying whether the target coordinates should
 *          be <c DIEFF_POLAR> or <c DIEFF_SPHERICAL>.
 *
 *          Polar and spherical coordinates differ only in their
 *          treatment of the first angle.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_CartToAngles(DWORD cAxes,
                    LPLONG rglAngles, const LONG *rglCart, DWORD dieff)
{
    HRESULT hres;
    FPTYPE r;
    DWORD iAxis;

    AssertF(cAxes);
    AssertF(dieff == DIEFF_POLAR || dieff == DIEFF_SPHERICAL);

	/*
	 * If we're converting a 1-axis cartesian effect
	 * the value of rglAngles[0] will not be overwritten;
	 * the value that is put there initially can be random, 
	 * since rglAngles is never initialized (Whistler bug 228280).
	 * but we can't change this behaviour without potentially
	 * breaking compatibility w/ some devices.
	 * The best we can do is to print out a warning in debug.
	 */
	if (cAxes == 1)
	{
		RPF("Warning: converting a 1-axis cartesian effect to polar or spherical coordinates: the results will be undefined.");
	}

    /*
     *  Prime the pump.
     */
    r = rglCart[0];

    /*
     *  Then walk the coordinates, converting to angles as we go.
     */
    for (iAxis = 1; iAxis < cAxes; iAxis++) {
        FPTYPE y = rglCart[iAxis];
        rglAngles[iAxis-1] = CDIEff_IntAtan2(y, r);
        r = sqrt(r * r + y * y);
    }

    /*
     *  The last coordinate is left garbage.
     *
     *  NOTE!  Mathematically, the last coordinate is r.
     */

    /*
     *  Adjust for DIEFF_POLAR.
     *
     *  theta(polar) = theta(spherical) + 90deg
     */

    if (dieff & DIEFF_POLAR) {
        rglAngles[0] += 90 * DI_DEGREES;
    }

    hres = S_OK;

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_AnglesToCart |
 *
 *          Convert angle-based coordinates
 *          (either polar or spherical)
 *          to cartesian coordinates.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes involved, never zero.
 *
 *  @parm   LPLONG | rglCart |
 *
 *          Buffer to receive cartesian coordinates.
 *
 *  @parm   LPCLONG | rglAngles |
 *
 *          Buffer containing existing angle-base coordinates.
 *
 *  @parm   DWORD | dieff |
 *
 *          Flags specifying whether the source coordinates are
 *          <c DIEFF_POLAR> or <c DIEFF_SPHERICAL>.
 *
 *          Polar and spherical coordinates differ only in their
 *          treatment of the first angle.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_AnglesToCart(DWORD cAxes,
                    LPLONG rglCart, const LONG *rglAngles, DWORD dieff)
{
    HRESULT hres;
    FPTYPE x[DIEFFECT_MAXAXES];
    DWORD iAxis;
    DWORD lAngle;

    AssertF(cAxes);
    AssertF(cAxes <= DIEFFECT_MAXAXES);
    AssertF(dieff == DIEFF_POLAR || dieff == DIEFF_SPHERICAL);

    /*
     *  Prime the pump.
     */
    x[0] = 1.0;

    /*
     *  For each angle, rotate in that direction.
     *
     *  If polar, then the first angle is biased by 90deg,
     *  so unbias it.
     *
     *  theta(spherical) = theta(polar) - 90deg
     */
    lAngle = rglAngles[0];
    if (dieff & DIEFF_POLAR) {
        lAngle -= 90 * DI_DEGREES;
    }

    for (iAxis = 1; iAxis < cAxes; iAxis++) {
        DWORD iX;
        FPTYPE theta, costh;

        theta = CDIEff_IntToAngle(lAngle);

        x[iAxis] = sin(theta);

        /*
         *  Compiler wont hoist this expression.
         *
         *  It also wont use the FSINCOS instruction.
         */
        costh = cos(theta);
        for (iX = 0; iX < iAxis; iX++) {
            x[iX] *= costh;
        }

        /*
         *  Note that this is safe because the angle array
         *  always contains an extra zero.
         */
        lAngle = rglAngles[iAxis];
    }

    /*
     *  Now convert the floating point values to scaled integers.
     */
    for (iAxis = 0; iAxis < cAxes; iAxis++) {
        rglCart[iAxis] = (LONG)(x[iAxis] * DI_FFNOMINALMAX);
    }

    hres = S_OK;

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   DWORD | CDIEff_ConvertDirection |
 *
 *          Given coordinates in a source system and a target system,
 *          convert them.
 *
 *          There are three possible source systems and three
 *          possible destination systems.
 *
 *          Yes, this is the most annoying thing you could imagine.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes involved, never zero.
 *
 *  @parm   LPLONG | rglDst |
 *
 *          Buffer to receive target coordinates.
 *
 *  @parm   DWORD | dieffDst |
 *
 *          Coordinate systems supported by target.  As many bits
 *          may be set as are supported by the target, but at least
 *          one must be set.
 *
 *  @parm   LPCLONG | rglSrc |
 *
 *          Buffer containing source coordinates.
 *
 *  @parm   DWORD | dieffSrc |
 *
 *          Coordinate system of source.  Exactly one bit should be set.
 *
 *  @returns
 *
 *          Returns the coordinate system stored into the target.
 *
 *****************************************************************************/

DWORD INTERNAL
CDIEff_ConvertDirection(DWORD cAxes,
                        LPLONG rglDst, DWORD dieffDst,
                        const LONG *rglSrc, DWORD dieffSrc)
{
    DWORD dieffRc;
    HRESULT hres;

    dieffSrc &= DIEFF_COORDMASK;
    dieffDst &= DIEFF_COORDMASK;

    AssertF(cAxes);
    AssertF(dieffDst);

    AssertF(dieffSrc == DIEFF_CARTESIAN ||
            dieffSrc == DIEFF_POLAR     ||
            dieffSrc == DIEFF_SPHERICAL);

    if (dieffSrc & dieffDst) {
        /*
         *  The easy case:  The two are directly compatible.
         *
         *  Just slam the bits across and copy the format.
         */
        CopyMemory(rglDst, rglSrc, cbCdw(cAxes));
        dieffRc = dieffSrc;

    } else

    /*
     *  If they two are not directly compatible, see if
     *  the source is cartesian.
     */

    if (dieffSrc & DIEFF_CARTESIAN) {
        /*
         *  Source is cartesian, dest is something angular.
         *  Choose DIEFF_SPHERICAL if possible.
         */
        AssertF(dieffDst & DIEFF_ANGULAR);

        dieffRc = dieffDst & DIEFF_SPHERICAL;
        if (dieffRc == 0) {
            AssertF(dieffDst & DIEFF_POLAR);
            dieffRc = DIEFF_POLAR;
        }

        hres = CDIEff_CartToAngles(cAxes, rglDst, rglSrc, dieffRc);
        AssertF(SUCCEEDED(hres));

    } else

    /*
     *  The two are not directly compatible, and the source is
     *  not cartesian.  This means that the source is one of the
     *  angular forms.  The destination is a combination of
     *  the other angular form or cartesian.
     */

    if (dieffDst & DIEFF_ANGULAR) {
        /*
         *  Source is angular, dest is the other angular.
         */

        AssertF(dieffSrc & DIEFF_ANGULAR);
        AssertF((dieffSrc & dieffDst) == 0);

        /*
         *  First copy everything over,
         */
        CopyMemory(rglDst, rglSrc, cbCdw(cAxes));

        /*
         *  Now rotate left or right, depending on which way
         *  we're going.
         */
        if (dieffSrc & DIEFF_POLAR) {
            /*
             *  Polar to spherical:  Subtract 90deg.
             */
            rglDst[0] -= 90 * DI_DEGREES;
        } else {
            /*
             *  Spherical to polar: Add 90deg.
             */
            rglDst[0] += 90 * DI_DEGREES;
        }

        dieffRc = dieffDst & DIEFF_ANGULAR;

    } else

    /*
     *  All that's left is the source is angular and the destination
     *  is cartesian.
     */
    {
        AssertF(dieffSrc & DIEFF_ANGULAR);
        AssertF(dieffDst & DIEFF_CARTESIAN);

        hres = CDIEff_AnglesToCart(cAxes, rglDst, rglSrc, dieffSrc);
        dieffRc = DIEFF_CARTESIAN;

    }

    /*
     *  If the resulting coordinate system is angular, then
     *  normalize all the angles.
     */
    if (dieffRc & DIEFF_ANGULAR) {
        DWORD iAxis;

        /*
         *  Remember, the last entry is not a direction.
         */
        for (iAxis = 0; iAxis < cAxes - 1; iAxis++) {

            /*
             *  An annoying artifact of the C language is that
             *  the sign of the result of a % operation when the
             *  numerator is negative and the denominator is
             *  positive is implementation-defined.  The standard
             *  does require that the absolute value of the result
             *  not exceed the denominator, so a quick final
             *  check brings things back into focus.
             */
            rglDst[iAxis] %= 360 * DI_DEGREES;
            if (rglDst[iAxis] < 0) {
                rglDst[iAxis] += 360 * DI_DEGREES;
            }
        }

        /*
         *  As always, the last coordinate is zero.
         */
        rglDst[cAxes - 1] = 0;
    }

    return dieffRc;

}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | SyncShepHandle |
 *
 *          Synchronize our private <t SHEPHANDLE> with the
 *          <t SHEPHANDLE> of the parent device.  If they were
 *          out of sync, then mark the efect as completely dirty
 *          so it will get re-downloaded in full.
 *
 *  @cwrap  PDE | this
 *
 *  @returns
 *
 *          <c DI_OK> = <c S_OK>: The two were already in sync.
 *
 *          <c S_FALSE>: The two were not in sync and are now in sync.
 *
 *****************************************************************************/

HRESULT INTERNAL
CDIEff_SyncShepHandle(PDE this)
{
    HRESULT hres;

    hres = CDIDev_SyncShepHandle(this->pdev, &this->sh);

    if (hres == S_OK) {
    } else {
        /*
         *  We were out of sync with our dad.  CDIDev_SyncShepHandle
         *  already sync'd us with dad and wiped out the effect handle.
         *  All that's left is to dirty everything because there is
         *  nothing to update.
         */
        AssertF(hres == S_FALSE);
        this->diepDirty = DIEP_ALLPARAMS;
    }

    return hres;
}


/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | DownloadWorker |
 *
 *          Place the effect on the device.  All parameters have
 *          been validated and the critical section has already been
 *          taken.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Effect to send down to the device.
 *
 *          If we are downloading for real, then this is the
 *          <e CDIEff.effDev>.
 *
 *          If we are hoping to download, then this is the
 *          <e CDIEff.effTry>.
 *
 *  @parm   DWORD | fl |
 *
 *          Flags which specify which parameters are to be sent down
 *          to the driver as changed since last time.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *          <c DIERR_DEVICEFULL>: The device does not have enough
 *          available memory to download the effect.
 *
 *          <c DIERR_INPUTLOST> if acquisition has been lost.
 *
 *          <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
 *          but not exclusively, or if the device is not acquired
 *          at all.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_DownloadWorker_(this, peff, fl, z)                   \
       _CDIEff_DownloadWorker_(this, peff, fl)                      \

#endif

HRESULT INTERNAL
CDIEff_DownloadWorker_(PDE this, LPCDIEFFECT peff, DWORD fl, LPCSTR s_szProc)
{

	HRESULT hres;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  If we do not have acquisition, but we are coming from
     *  SetParameters, then turn it into a DIEP_NODOWNLOAD so
     *  the call will go through.
     */

    hres = CDIEff_CanAccess(this);
    if ((hres == DIERR_INPUTLOST || hres == DIERR_NOTEXCLUSIVEACQUIRED) &&
        peff == &this->effTry) {
        fl |= DIEP_NODOWNLOAD;
        hres = S_OK;
    }

    if (SUCCEEDED(hres)) {

        hres = CDIEff_SyncShepHandle(this);

        if (!(fl & DIEP_NODOWNLOAD)) {          /* If we are downloading */

            /*
             *  If there are still unset bits, then barf.
             */
            if (this->diepUnset & ~fl) {
                RPF("%s: Effect still incomplete; "
                    "DIEP flags %08x need to be set",
                    s_szProc, this->diepUnset);
                hres = DIERR_INCOMPLETEEFFECT;
                goto done;
            }

            /*
             *  Since we are downloading, pass down all dirty bits.
             */
            fl |= this->diepDirty;
        }

        /*
         *  Now call the driver to do the validation or
         *  the download (accordingly).
         *
         *  Note that if nothing is to be done, then there is no need
         *  to call the driver.
         */
		hres = IDirectInputEffectShepherd_DownloadEffect(
				this->pes, (this->dEffAttributes).dwEffectId, &this->sh, peff, fl);

        if (SUCCEEDED(hres)) {
            if (fl & DIEP_NODOWNLOAD) {
                hres = DI_DOWNLOADSKIPPED;
            } else {
                this->diepDirty = 0;
            }
        }

        AssertF(hres != DIERR_NOTDOWNLOADED);

    }

done:;
    return hres;


}

#define CDIEff_DownloadWorker(this, peff, fl)                       \
        CDIEff_DownloadWorker_(this, peff, fl, s_szProc)            \

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Download |
 *
 *          Place the effect on the device.  If the effect is already
 *          on the device, then the existing effect is updated to
 *          match the values set via <mf IDirectInputEffect::SetParameters>.
 *
 *          It is valid to update an effect while it is playing.
 *          The semantics of such an operation are explained in the
 *          documentation for <mf IDirectInputEffect::SetParameters>.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c S_FALSE>:  The effect has already been downloaded to the
 *          device.  Note that this is a success code.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *          <c DIERR_DEVICEFULL>: The device does not have enough
 *          available memory to download the effect.
 *
 *          <c DIERR_INPUTLOST> if acquisition has been lost.
 *
 *          <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
 *          but not exclusively, or if the device is not acquired
 *          at all.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *          <c DIERR_EFFECTPLAYING>: The parameters were updated in
 *          memory but were not downloaded to the device because
 *          the device does not support updating an effect while
 *          it is still playing.  In such case, you must stop the
 *          effect, change its parameters, and restart it.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Download(PDIE pdie)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::Download, (_ "p", pdie));

    if (SUCCEEDED(hres = hresPv(pdie))) {
        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        hres = CDIEff_DownloadWorker(this, &this->effDev, 0);

        CDIEff_LeaveCrit(this);

    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Unload |
 *
 *          Remove the effect from the device.
 *
 *          If the effect is playing, it is automatically stopped before
 *          it is unloaded.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *          <c DIERR_INPUTLOST> if acquisition has been lost.
 *
 *          <c DIERR_NOTEXCLUSIVEACQUIRED> the device is acquired,
 *          but not exclusively, or if the device is not acquired
 *          at all.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Unload(PDIE pdie)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::Unload, (_ "p", pdie));

    if (SUCCEEDED(hres = hresPv(pdie))) {
        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        hres = CDIEff_UnloadWorker(this);

        CDIEff_LeaveCrit(this);

    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | hresFullValidWritePeff |
 *
 *          Verify that the recipient buffer is valid to receive
 *          effect information.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   LPDIEFFECT | peff |
 *
 *          Structure that receives effect information.  It has
 *          already been validate in size and for general writeability.
 *
 *  @parm   DWORD | fl |
 *
 *          Zero or more <c DIEP_*> flags specifying which
 *          portions of the effect information is to be retrieved.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define hresFullValidWritePeff_(this, peff, fl, z, i)               \
       _hresFullValidWritePeff_(this, peff, fl)                     \

#endif

#define hresFullValidWritePeff(this, peff, fl, iarg)                \
        hresFullValidWritePeff_(this, peff, fl, s_szProc, iarg)     \


HRESULT INTERNAL
hresFullValidWritePeff_(PDE this, LPDIEFFECT peff, DWORD fl,
                        LPCSTR s_szProc, int iarg)
{
    HRESULT hres;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  You can't get the parameters of a nonexistent effect.
     */
    if (!this->fInitialized) {
        hres = DIERR_NOTINITIALIZED;
        goto done;
    }

    /*
     *  Flags are always validated.
     */
    if (peff->dwFlags & ~DIEFF_VALID) {
        RPF("ERROR %s: arg %d: Invalid value 0x%08x in DIEFFECT.dwFlags",
            s_szProc, iarg, peff->dwFlags);
        hres = E_INVALIDARG;
        goto done;
    }

    /*
     *  If requesting something that requires object ids or offsets,
     *  make sure the caller picks one or the other.
     */
    if (fl & DIEP_USESOBJECTS) {
        switch (peff->dwFlags & DIEFF_OBJECTMASK) {
        case DIEFF_OBJECTIDS:
        case DIEFF_OBJECTOFFSETS:
            break;

        default:
            RPF("ERROR %s: arg %d: Must specify one of "
                "DIEFF_OBJECTIDS or DIEFF_OBJECTOFFSETS", s_szProc, iarg);
            hres = E_INVALIDARG;
            goto done;
        }

    }

    /*
     *  If requesting something that requires direction coordinates,
     *  make sure the caller picks something we can return.
     */
    if (fl & DIEP_USESCOORDS) {

        /*
         *  Polar coordinates require cAxes == 2.  If not, then
         *  turn off DIEFF_POLAR so we won't return it.
         *
         *  But the place where we check the number of axes is
         *  in the effect itself, not in the input buffer.
         *  The reason is that the caller might be passing cAxes=0
         *  intending to ping the number of axes, and I don't
         *  want to return an error or the app will get confused
         *  and panic.
         */
        if (this->effDev.cAxes != 2 && (peff->dwFlags & DIEFF_POLAR)) {
            RPF("WARNING %s: arg %d: DIEFF_POLAR requires DIEFFECT.cAxes=2",
                s_szProc, 1);
            peff->dwFlags &= ~DIEFF_POLAR;
        }

        /*
         *  There'd better be a coordinate system left.
         */
        if ((peff->dwFlags & DIEFF_COORDMASK) == 0) {
            RPF("ERROR %s: arg %d: No (valid) coordinate system "
                "in DIEFFECT.dwFlags", s_szProc, 1);
            hres = E_INVALIDARG;
            goto done;
        }

    }

    /*
     *  DIEP_DURATION
     *  DIEP_SAMPLEPERIOD
     *  DIEP_GAIN
     *  DIEP_TRIGGERBUTTON
     *  DIEP_TRIGGERREPEATINTERVAL
     *                - Simple dwords.  No extra validation needed.
     */

#if DIRECTINPUT_VERSION >= 0x0600
    /*
     *  DIEP_STARTDELAY
     *                - Although this is a simple DWORD, we do some
     *                  sanity warnings because vendors will probably
     *                  forget to initialize it.  Also, you can't pass
     *                  this flag if your structure isn't big enough.
     */
    if (fl & DIEP_STARTDELAY) {
        if (peff->dwSize < cbX(DIEFFECT_DX6)) {
            RPF("ERROR %s: arg %d: Can't use DIEP_STARTDELAY with "
                "DIEFFECT_DX5 structure", s_szProc, 1);
        }

        /*
         *  Sanity checks.  A delay that isn't a multiple of 50ms is
         *  probably a bug.
         */
        if (peff->dwStartDelay % 50000) {
            RPF("WARNING %s: DIEFFECT.dwStartDelay = %d seems odd",
                s_szProc, peff->dwStartDelay);
        }
    }
#endif

    /*
     *  DIEP_TYPESPECIFICPARAMS
     *                - Validate that the buffer is big enough.
     */

    AssertF(this->hresValidTsd);
    if ((fl & DIEP_TYPESPECIFICPARAMS) &&
        FAILED(hres = hresFullValidWritePvCb(peff->lpvTypeSpecificParams,
                                             peff->cbTypeSpecificParams,
                                             iarg))) {
        RPF("ERROR %s: arg %d: Invalid pointer in "
            "DIEFFECT.lpvTypeSpecificParams", s_szProc, iarg);
        goto done;
    }

    /*
     *  DIEP_AXES
     *  DIEP_DIRECTION
     *                - The buffers must be of necessary size.
     */
    if ((fl & DIEP_AXES) &&
        FAILED(hres = hresFullValidWritePvCb(peff->rgdwAxes,
                                             cbCdw(peff->cAxes), iarg))) {
        RPF("ERROR %s: arg %d: Invalid pointer in DIEFFECT.rgdwAxes",
            s_szProc, iarg);
        goto done;
    }

    if ((fl & DIEP_DIRECTION) &&
        FAILED(hres = hresFullValidWritePvCb(peff->rglDirection,
                                             cbCdw(peff->cAxes), iarg))) {
        RPF("ERROR %s: arg %d: Invalid pointer in DIEFFECT.rglDirection",
            s_szProc, iarg);
        goto done;
    }

    /*
     *  DIEP_ENVELOPE - The pointer must be valid to receive the envelope.
     */
    if ((fl & DIEP_ENVELOPE) &&
        FAILED(hres = hresFullValidWritePxCb(peff->lpEnvelope,
                                             DIENVELOPE, iarg))) {
        RPF("ERROR %s: arg %d: Invalid pointer in DIEFFECT.lpEnvelope",
            s_szProc, iarg);
        goto done;
    }

    hres = S_OK;

done:;
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | MapDwords |
 *
 *          Map a few <t DWORD>s based on the desired mapping mode
 *          of the caller.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   DWORD | dwFlags |
 *
 *          The mapping mode desired by the caller.
 *
 *  @parm   UINT | cdw |
 *
 *          Number of items to convert.
 *
 *  @parm   LPDWORD | rgdwOut |
 *
 *          Destination buffer.
 *
 *  @parm   LPCDWORD | rgdwIn |
 *
 *          Source buffer.
 *
 *  @parm   UINT | devco |
 *
 *          Conversion code describing what we're converting.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  The caller
 *          requested offsets but there is no data format selected.
 *
 *****************************************************************************/

#if 0

#ifndef XDEBUG

#define CDIEff_MapDwords_(this, fl, cdw, rgdwOut, rgdwIn, devco, z, i)  \
       _CDIEff_MapDwords_(this, fl, cdw, rgdwOut, rgdwIn, devco)        \

#endif

#define CDIEff_MapDwords(this, fl, cdw, rgdwOut, rgdwIn, devco, i)      \
        CDIEff_MapDwords_(this, fl, cdw, rgdwOut, rgdwIn, devco, s_szProc, i) \

#endif

HRESULT INTERNAL
CDIEff_MapDwords(PDE this, DWORD dwFlags,
                 UINT cdw, LPDWORD rgdwOut, const DWORD *rgdwIn, UINT devco)
{
    HRESULT hres;

    AssertF(CDIDev_InCrit(this->pdev));

    if (cdw) {

        CopyMemory(rgdwOut, rgdwIn, cbCdw(cdw));

        /*
         *  Okay, now things get weird.  We internally keep the
         *  items as item IDs, because that's what drivers
         *  want.  So we need to convert them to whatever the
         *  caller really wants.
         */

        if (dwFlags & DIEFF_OBJECTOFFSETS) {
            if (devco & DEVCO_FROMID) {
                devco |= DEVCO_TOOFFSET;
            } else {
                AssertF(devco & DEVCO_TOID);
                devco |= DEVCO_FROMOFFSET;
            }
        } else {
            AssertF(dwFlags & DIEFF_OBJECTIDS);
            if (devco & DEVCO_FROMID) {
                devco |= DEVCO_TOID;
            } else {
                AssertF(devco & DEVCO_TOID);
                devco |= DEVCO_FROMID;
            }
        }
        hres = CDIDev_ConvertObjects(this->pdev, cdw, rgdwOut, devco);

    } else {
        /* Vacuous success */
        hres = S_OK;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method void | CDIEff | GetDirectionParameters |
 *
 *          Retrieve information about the direction of an effect.
 *
 *          If no direction has yet been set, then wipe out the
 *          direction pointer and erase the coordinate system.
 *
 *          Always convert from the cached application coordinate
 *          system instead of the device coordinate system, in
 *          order to maximize fidelity.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPDIEFFECT | peff |
 *
 *          Structure to receive effect information.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes to return.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_GetDirectionParameters_(this, peff, cAxes, z, iarg)  \
       _CDIEff_GetDirectionParameters_(this, peff, cAxes)           \

#endif

#define CDIEff_GetDirectionParameters(this, peff, cAxes, iarg)      \
        CDIEff_GetDirectionParameters_(this, peff, cAxes, s_szProc, iarg)  \

void INTERNAL
CDIEff_GetDirectionParameters_(PDE this, LPDIEFFECT peff, DWORD cAxes,
                               LPCSTR s_szProc, int iarg)
{
    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  Make sure there are no non-coordinate bits in dwDirFlags.
     *  And validation should've made sure the app is asking for *something*.
     */
    AssertF((this->dwDirFlags & ~DIEFF_COORDMASK) == 0);
    AssertF(peff->dwFlags & DIEFF_COORDMASK);
    AssertF(cAxes <= DIEFFECT_MAXAXES);

    if (this->dwDirFlags) {
        DWORD dieffRc;
        LONG rgl[DIEFFECT_MAXAXES];     /* Holding buffer */

        /*
         *  We must double-buffer in case the target is not big enough.
         */
		/*
         *  Prefix does not like the lack of initialization of rgl (Manbugs 34566, Whistler 228280 -- 
		 *  althought the bugs refer to dinput8.dll, the same problem is present in dinput.dll). 
         *  but unfortunately we can't fix it without potentially breaking compatibility
		 *  with some devices. See comment in CDIEff_CartToAngles() about this issue.
		 */
        dieffRc = CDIEff_ConvertDirection(
                        this->effDev.cAxes,
                        rgl, peff->dwFlags,
                        this->rglDirApp, this->dwDirFlags);

        peff->dwFlags = (peff->dwFlags & ~DIEFF_COORDMASK) | dieffRc;

        CopyMemory(peff->rglDirection, rgl, cbCdw(cAxes));

    } else {
        /*
         *  No direction set; vacuous success.
         */
        RPF("Warning: %s: arg %d: Effect has no direction", s_szProc, iarg);
        peff->rglDirection = 0;
        peff->dwFlags &= ~DIEFF_COORDMASK;
    }

}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | GetParameters |
 *
 *          Retrieve information about an effect.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   LPDIEFFECT | peff |
 *
 *          Structure that receives effect information.
 *          The <e DIEFFECT.dwSize> field must be filled in by
 *          the application before calling this function.
 *
 *  @parm   DWORD | dwFlags |
 *
 *          Zero or more <c DIEP_*> flags specifying which
 *          portions of the effect information is to be retrieved.
 *
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has never had any effect parameters set into it.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.  Common errors include
 *          not setting the <e DIEFFECT.dwSize> field of the
 *          <t DIEFFECT> structure, passing invalid flags,
 *          or not setting up the fields in the <t DIEFFECT> structure
 *          properly in preparation for receiving the effect information.
 *
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_GetParameters(PDIE pdie, LPDIEFFECT peff, DWORD fl)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::GetParameters, (_ "ppx", pdie, peff, fl));

    /*
     *  Note that we cannot use hresFullValidWritePxCb() because
     *  that will scramble the buffer, but we still need the values
     *  in it.
     */
    if (SUCCEEDED(hres = hresPv(pdie)) &&
#if DIRECTINPUT_VERSION >= 0x0600
        SUCCEEDED( hres = ( IsBadReadPtr(&peff->dwSize, cbX(peff->dwSize)) ) ? E_POINTER : S_OK ) &&
        ( ( (peff->dwSize != cbX(DIEFFECT_DX5)) &&
            SUCCEEDED(hres = hresFullValidWriteNoScramblePxCb(peff, DIEFFECT_DX6, 1) ) &&
            SUCCEEDED(hres = hresFullValidFl(fl, DIEP_GETVALID, 2)) )
          ||
          ( SUCCEEDED(hres = hresFullValidWriteNoScramblePxCb(peff, DIEFFECT_DX5, 1)) &&
            SUCCEEDED(hres = hresFullValidFl(fl, DIEP_GETVALID_DX5, 2)) )
        ) ) {
#else
        SUCCEEDED(hres = hresFullValidWriteNoScramblePxCb(peff, DIEFFECT_DX5, 1)) &&
        SUCCEEDED(hres = hresFullValidFl(fl, DIEP_GETVALID_DX5, 2))) {
#endif

        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        if (SUCCEEDED(hres = hresFullValidWritePeff(this, peff, fl, 1))) {

            if (fl == 0) {
                RPF("Warning: %s(dwFlags=0) is pretty useless",
                    s_szProc);
            }

            /*
             *  Assume everything is okay.
             */
            hres = S_OK;

            /*
             *  Pull out the effect parameters.
             */

            if (fl & DIEP_DURATION) {
                peff->dwDuration = this->effDev.dwDuration;
            }

            if (fl & DIEP_SAMPLEPERIOD) {
                peff->dwSamplePeriod = this->effDev.dwSamplePeriod;
            }

            if (fl & DIEP_GAIN) {
                peff->dwGain = this->effDev.dwGain;
            }

#if DIRECTINPUT_VERSION >= 0x0600
            if (fl & DIEP_STARTDELAY) {
                peff->dwStartDelay = this->effDev.dwStartDelay;
            }
#endif

            if (fl & DIEP_TRIGGERBUTTON) {
                peff->dwTriggerButton = this->effDev.dwTriggerButton;
                if (peff->dwTriggerButton != DIEB_NOTRIGGER) {
                    hres = CDIEff_MapDwords(this, peff->dwFlags, 1,
                                            &peff->dwTriggerButton,
                                            &peff->dwTriggerButton,
                                            DEVCO_BUTTON |
                                            DEVCO_FROMID);

                    /*
                     *  We should never allow a bad id to sneak in.
                     */
                    AssertF(SUCCEEDED(hres));

                    if (FAILED(hres)) {
                        goto done;
                    }
                }
            }

            if (fl & DIEP_TRIGGERREPEATINTERVAL) {
                peff->dwTriggerRepeatInterval =
                                    this->effDev.dwTriggerRepeatInterval;
            }

            if (fl & DIEP_TYPESPECIFICPARAMS) {
                DWORD cb = this->effDev.cbTSP;
                if (peff->cbTSP < this->effDev.cbTSP) {
                    cb = peff->cbTSP;
                    hres = DIERR_MOREDATA;
                }
                peff->cbTSP = this->effDev.cbTSP;

                CopyMemory(peff->lpvTSP, this->effDev.lpvTSP, cb);
            }

            if (fl & DIEP_ENVELOPE) {
                if (this->effDev.lpEnvelope) {
                    *peff->lpEnvelope = *this->effDev.lpEnvelope;
                } else {
                    /*
                     *  Zero out the envelope because apps won't
                     *  check whether peff->lpEnvelope == 0;
                     *  they're just going to peek at the envelope
                     *  even if the effect doesn't have one.
                     */
                    ZeroMemory(pvAddPvCb(peff->lpEnvelope,
                                         cbX(peff->lpEnvelope->dwSize)),
                               cbX(DIENVELOPE) -
                                         cbX(peff->lpEnvelope->dwSize));
                    peff->lpEnvelope = this->effDev.lpEnvelope;
                }
            }

            /*
             *  Do axes and direction last because weird error
             *  codes can come out of here.
             */
            if (fl & (DIEP_AXES | DIEP_DIRECTION)) {

                DWORD cAxes = this->effDev.cAxes;
                if (peff->cAxes < this->effDev.cAxes) {
                    cAxes = peff->cAxes;
                    peff->cAxes = this->effDev.cAxes;
                    hres = DIERR_MOREDATA;
                }
                peff->cAxes = this->effDev.cAxes;

                if (fl & DIEP_AXES) {
                    HRESULT hresT;
                    hresT = CDIEff_MapDwords(this, peff->dwFlags, cAxes,
                                             peff->rgdwAxes,
                                             this->effDev.rgdwAxes,
                                             DEVCO_AXIS |
                                             DEVCO_FROMID);
                    if (FAILED(hresT)) {
                        RPF("ERROR: %s: arg %d: Axes not in data format",
                             s_szProc, 1);
                        hres = hresT;
                        goto done;
                    }
                }

                if (fl & DIEP_DIRECTION) {
                    CDIEff_GetDirectionParameters(this, peff, cAxes, 1);
                }

            }
        }

    done:;
        CDIEff_LeaveCrit(this);
    }

    ExitOleProc();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidUnknownTsd |
 *
 *          Verify that the buffer is a valid buffer for unknown
 *          type-specific data.  Since we don't know what it is,
 *          the buffer is assumed valid because we can't validate it.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidUnknownTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    peff;
    cAxes;

    hres = S_OK;

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidConstantTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DICONSTANTFORCE> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidConstantTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

        if (peff->cbTypeSpecificParams == cbX(DICONSTANTFORCE)) {
            hres = S_OK;
        } else {
            hres = E_INVALIDARG;
        }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidRampTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DIRAMPFORCE> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidRampTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

        if (peff->cbTypeSpecificParams == cbX(DIRAMPFORCE)) {
            hres = S_OK;
        } else {
            hres = E_INVALIDARG;
        }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidPeriodicTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DIPERIODIC> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidPeriodicTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

        if (peff->cbTypeSpecificParams == cbX(DIPERIODIC)) {
            hres = S_OK;
        } else {
            hres = E_INVALIDARG;
        }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidConditionTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DICONDITION> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidConditionTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    /*
     *  Conditions are weird.  The size of the type-specific data
     *  must be equal to cAxes * cbX(DICONDITION) or equal to
     *  exactly one cbX(DICONDITION), depending on whether you want
     *  multiple conditions on multiple axes or a single condition
     *  rotated across multiple axes.
     *
     *  Note that we do not enforce that the parameters are in range;
     *  this allows for "overgain"-type behaviors.
     */

    if (peff->cbTypeSpecificParams ==         cbX(DICONDITION) ||
        peff->cbTypeSpecificParams == cAxes * cbX(DICONDITION)) {
        hres = S_OK;
    } else {
        RPF("IDirectInputEffect::SetParameters: "
            "Size of type-specific data (%d) "
            "not compatible with number of axes (%d)",
            peff->cbTypeSpecificParams, cAxes);
        hres = E_INVALIDARG;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidCustomForceTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DICUSTOMFORCE> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidCustomForceTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

        if (peff->cbTypeSpecificParams == cbX(DICUSTOMFORCE)) {
            LPCDICUSTOMFORCE pcf = peff->lpvTypeSpecificParams;
            if (pcf->cChannels == 0) {
                RPF("ERROR: IDirectInputEffect::SetParameters: "
                    "DICUSTOMFORCE.cChannels == 0 is invalid");
                hres = E_INVALIDARG;
            } else if (pcf->cSamples % pcf->cChannels != 0) {
                RPF("ERROR: IDirectInputEffect::SetParameters: "
                    "DICUSTOMFORCE.cSamples must be multiple of "
                    "DICUSTOMFORCE.cChannels");
                hres = E_INVALIDARG;
            } else if (IsBadReadPtr(pcf->rglForceData,
                                    cbCxX((pcf->cSamples)*(pcf->cChannels), LONG))) {
                RPF("ERROR: IDirectInputEffect::SetParameters: "
                    "DICUSTOMFORCE.rglForceData invalid");
                hres = E_INVALIDARG;
            } else {
                hres = S_OK;
            }
        } else {
            hres = E_INVALIDARG;
        }

    return hres;
}

#if DIRECTINPUT_VERSION >= 0x0800
/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidRandomTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DIRANDOM> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidRandomTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

    if (peff->cbTypeSpecificParams == cbX(DIRANDOM)) {
        hres = S_OK;
    } else {
        hres = E_INVALIDARG;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidAbsoluteTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DIABSOLUTE> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidAbsoluteTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

    /*
     *  Unlike other effects, "overgain" is not permitted for absolute effects.
     */
    if (peff->cbTypeSpecificParams == cbX(DIABSOLUTE)) 
    {
        LPCDIABSOLUTE pabs = peff->lpvTypeSpecificParams;
        if( fInOrder( -10000, pabs->lTarget, 10000 ) )
        {
            hres = S_OK;
        }
        else
        {
            RPF("ERROR: IDirectInputEffect::SetParameters: "
                "DIABSOLUTE.lTarget %d not in range -10000 to 100000", 
                pabs->lTarget );
            hres = E_INVALIDARG;
        }
    } else {
        hres = E_INVALIDARG;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidBumpForceTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DIBUMPFORCE> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidBumpForceTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    cAxes;

    if (peff->cbTypeSpecificParams == cbX(DIBUMPFORCE)) {
        LPCDIBUMPFORCE pbf = peff->lpvTypeSpecificParams;
        if (pbf->cChannels == 0) {
            RPF("ERROR: IDirectInputEffect::SetParameters: "
                "DIBUMPFORCE.cChannels == 0 is invalid");
            hres = E_INVALIDARG;
        } else if (pbf->cSamples % pbf->cChannels != 0) {
            RPF("ERROR: IDirectInputEffect::SetParameters: "
                "DIBUMPFORCE.cSamples must be multiple of "
                "DIBUMPFORCE.cChannels");
            hres = E_INVALIDARG;
        } else if (IsBadReadPtr(pbf->rglForceData,
                                cbCxX(pbf->cSamples, LONG))) {
            RPF("ERROR: IDirectInputEffect::SetParameters: "
                "DIBUMPFORCE.rglForceData invalid");
            hres = E_INVALIDARG;
        } else {
            hres = S_OK;
        }
    } else {
        hres = E_INVALIDARG;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | CDIEff_IsValidConditionExTsd |
 *
 *          Verify that the buffer is a valid
 *          <t DICONDITIONEX> structure.
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The type-specific parameters have already been validated
 *          for access.
 *
 *  @parm   DWORD | cAxes |
 *
 *          Number of axes associated with the type-specific parameters.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_IsValidConditionExTsd(LPCDIEFFECT peff, DWORD cAxes)
{
    HRESULT hres;

    /*
     *  Extended conditions, like conditions are weird.  
     *  The size of the type-specific data
     *  must be equal to cAxes * cbX(DICONDITIONEX) or equal to
     *  exactly one cbX(DICONDITIONEX), depending on whether you want
     *  multiple conditions on multiple axes or a single condition
     *  rotated across multiple axes.
     *
     *  Note that we do not enforce that the parameters are in range;
     *  this allows for "overgain"-type behaviors.
     */

    if (peff->cbTypeSpecificParams ==         cbX(DICONDITIONEX) ||
        peff->cbTypeSpecificParams == cAxes * cbX(DICONDITIONEX)) {
        hres = S_OK;
    } else {
        RPF("IDirectInputEffect::SetParameters: "
            "Size of type-specific data (%d) "
            "not compatible with number of axes (%d)",
            peff->cbTypeSpecificParams, cAxes);
        hres = E_INVALIDARG;
    }

    return hres;
}
#endif /* DIRECTINPUT_VERSION >= 0x0800 */

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @func   HRESULT | hresFullValidPeff |
 *
 *          Verify that the recipient buffer contains valid information.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.  It has
 *          already been validate in size and for general readability.
 *
 *  @parm   DWORD | fl |
 *
 *          Zero or more <c DIEP_*> flags specifying which
 *          portions of the effect information should be validated.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define hresFullValidPeff_(this, peff, fl, z, i)                    \
       _hresFullValidPeff_(this, peff, fl)                          \

#endif

#define hresFullValidPeff(this, peff, fl, iarg)                     \
        hresFullValidPeff_(this, peff, fl, s_szProc, iarg)          \


HRESULT INTERNAL
hresFullValidPeff_(PDE this, LPCDIEFFECT peff, DWORD fl,
                   LPCSTR s_szProc, int iarg)
{
    HRESULT hres;
    DWORD cAxes;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  You can't set the parameters of a nonexistent effect.
     */
    if (!this->fInitialized) {
        hres = DIERR_NOTINITIALIZED;
        goto done;
    }

    /*
     *  Flags are always validated.
     */
    if (peff->dwFlags & ~DIEFF_VALID) {
        RPF("ERROR %s: arg %d: Invalid flags specific parms in DIEFFECT",
            s_szProc, iarg);
        hres = E_INVALIDARG;
        goto done;
    }

    /*
     *  If setting something that requires object ids or offsets,
     *  make sure the caller picks one or the other.
     */
    if (fl & DIEP_USESOBJECTS) {
        switch (peff->dwFlags & DIEFF_OBJECTMASK) {
        case DIEFF_OBJECTIDS:
        case DIEFF_OBJECTOFFSETS:
            break;

        default:
            RPF("ERROR %s: arg %d: Must specify one of "
                "DIEFF_OBJECTIDS or DIEFF_OBJECTOFFSETS", s_szProc, iarg);
            hres = E_INVALIDARG;
            goto done;
        }

    }

    /*
     *  If setting something that requires direction coordinates,
     *  make sure the caller picks exactly one.
     */
    if (fl & DIEP_USESCOORDS) {
        switch (peff->dwFlags & DIEFF_COORDMASK) {
        case DIEFF_CARTESIAN:
        case DIEFF_SPHERICAL:
            break;

        /*
         *  Polar coordinates mandate two (and only two) axes.
         */
        case DIEFF_POLAR:
            if (peff->cAxes != 2) {
                RPF("ERROR %s: arg %d: DIEFF_POLAR requires DIEFFECT.cAxes=2",
                    s_szProc, 1);
                hres = E_INVALIDARG;
                goto done;
            }
            break;

        default:
            RPF("ERROR %s: arg %d: Must specify one of "
                "DIEFF_CARTESIAN, DIEFF_POLAR, or DIEFF_SPHERICAL",
                s_szProc, iarg);
            hres = E_INVALIDARG;
            goto done;
        }

    }

    /*
     *  DIEP_DURATION
     *  DIEP_SAMPLEPERIOD
     *  DIEP_GAIN
     *  DIEP_TRIGGERBUTTON
     *                - Simple dwords.  No extra validation needed.
     */

    /*
     *  DIEP_AXES
     *  DIEP_DIRECTION
     *                - The buffers must be of necessary size.
     *
     *  We will validate the other goo later, because there
     *  are annoying interactions between them.
     */

    AssertF(fLeqvFF(this->effDev.cAxes == 0, this->diepUnset & DIEP_AXES));

    cAxes = this->effDev.cAxes;
    if (fl & (DIEP_AXES | DIEP_DIRECTION)) {

        /*
         *  The number of axes had better not be zero.
         */

        if (peff->cAxes == 0) {
            RPF("ERROR %s: arg %d: DIEFFECT.cAxes = 0 is invalid",
                s_szProc, iarg);
            hres = E_INVALIDARG;
            goto done;
        }

        /*
         *  And it better not be too big either.
         */

        if (peff->cAxes > DIEFFECT_MAXAXES) {
            RPF("ERROR %s: arg %d: DIEFFECT.cAxes = %d is too large (max %d)",
                s_szProc, iarg, peff->cAxes, DIEFFECT_MAXAXES);
            hres = E_INVALIDARG;
            goto done;
        }

        if (fl & DIEP_AXES) {

            /*
             *  If the axes have already been set (which we know because
             *  this->effDev.cAxes will be nonzero), then don't
             *  let the caller change them.
             */

            if (this->effDev.cAxes) {
                RPF("ERROR %s: arg %d: Cannot change axes once set",
                    s_szProc, iarg);
                hres = DIERR_ALREADYINITIALIZED;
                goto done;
            }

            cAxes = peff->cAxes;

            if (IsBadReadPtr(peff->rgdwAxes, cbCdw(peff->cAxes))) {
                RPF("ERROR %s: arg %d: Invalid rgdwAxes in DIEFFECT",
                    s_szProc, iarg);
                hres = E_INVALIDARG;
                goto done;
            }
        }

        if (fl & DIEP_DIRECTION) {

            /*
             *  We want to disallow cAxes == 0 as well,
             *  but we get that for free because
             *  peff->cAxes != cAxes, and peff->cAxes is already
             *  validated as nonzero.
             */
            if (peff->cAxes != cAxes) {
                if (cAxes) {
                    RPF("ERROR %s: arg %d: Wrong number of DIEFFECT.cAxes",
                        s_szProc, 1);
                } else {
                    RPF("ERROR %s: arg %d: "
                        "Must set number of axes before directions", s_szProc);
                }
                hres = E_INVALIDARG;
                goto done;
            }

            /*
             *  Direction validation should've already checked above.
             */
            AssertF(fLimpFF(peff->dwFlags & DIEFF_POLAR, peff->cAxes == 2));

            if (IsBadReadPtr(peff->rglDirection, cbCdw(peff->cAxes))) {
                RPF("ERROR %s: arg %d: Invalid rglDirection in DIEFFECT",
                    s_szProc, iarg);
                hres = E_INVALIDARG;
                goto done;

            }
        }
    }

    /*
     *  DIEP_TYPESPECIFICPARAMS
     *                - Validate that the buffer is valid
     *                  and passes type-specific tests.
     *
     *  This must be done after axes so we know how many
     *  axes there are.
     */

    AssertF(this->hresValidTsd);
    if (fl & DIEP_TYPESPECIFICPARAMS) {
        hres = hresFullValidReadPvCb(peff->lpvTypeSpecificParams,
                                     peff->cbTypeSpecificParams, iarg);
        if (FAILED(hres)) {
            RPF("ERROR %s: arg %d: Invalid pointer in "
                "DIEFFECT.lpvTypeSpecificParams",
                s_szProc, iarg);
            hres = E_INVALIDARG;
            goto done;
        }

        hres = this->hresValidTsd(peff, cAxes);
        if (FAILED(hres)) {
            RPF("ERROR %s: arg %d: Invalid type-specific data",
                s_szProc, iarg);
            goto done;
        }
    }

    /*
     *  DIEP_ENVELOPE - The pointer must be valid if present.
     */
    if ((fl & DIEP_ENVELOPE) &&
        peff->lpEnvelope &&
        FAILED(hres = hresFullValidReadPxCb(peff->lpEnvelope,
                                            DIENVELOPE, iarg))) {
        RPF("ERROR %s: arg %d: Invalid lpEnvelope in DIEFFECT",
            s_szProc, iarg);
        hres = E_INVALIDARG;
        goto done;
    }

    hres = S_OK;

done:;
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | TryTriggerButton |
 *
 *          Set information about the trigger button for an effect into the
 *          temporary buffer.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_TryTriggerButton_(this, peff, z, iarg)               \
       _CDIEff_TryTriggerButton_(this, peff)                        \

#endif

#define CDIEff_TryTriggerButton(this, peff, iarg)                   \
        CDIEff_TryTriggerButton_(this, peff, s_szProc, iarg)        \


STDMETHODIMP
CDIEff_TryTriggerButton_(PDE this, LPCDIEFFECT peff, LPCSTR s_szProc, int iarg)
{
    HRESULT hres;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  We can copy directly in, because if something goes wrong,
     *  we just throw away effTry without damaging effDev.
     */

    this->effTry.dwTriggerButton = peff->dwTriggerButton;

    if (fLimpFF(this->effTry.dwTriggerButton != DIEB_NOTRIGGER,
        SUCCEEDED(hres = CDIEff_MapDwords(this, peff->dwFlags, 1,
                                          &this->effTry.dwTriggerButton,
                                          &this->effTry.dwTriggerButton,
                                          DEVCO_BUTTON |
                                          DEVCO_FFEFFECTTRIGGER |
                                          DEVCO_TOID)))) {
        hres = S_OK;
    } else {
        RPF("ERROR %s: Invalid button identifier/offset "
            "or button is not DIEB_NOTRIGGER",
            s_szProc);
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | TryAxis |
 *
 *          Set information about the axes of an effect into the
 *          temporary buffer.  Note that since you can't change the
 *          axes once they've been set, we can put our try directly
 *          into the final buffer.
 *
 *          The only tricky thing is making sure no axes are repeated
 *          in the array.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_TryAxis_(this, peff, z, iarg)                        \
       _CDIEff_TryAxis_(this, peff)                                 \

#endif

#define CDIEff_TryAxis(this, peff, iarg)                            \
        CDIEff_TryAxis_(this, peff, s_szProc, iarg)                 \


STDMETHODIMP
CDIEff_TryAxis_(PDE this, LPCDIEFFECT peff, LPCSTR s_szProc, int iarg)
{
    HRESULT hres;
    UINT idw;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  You can change the axes only once.  Therefore, rgdwAxes
     *  always points to this->rgdwAxes.
     */
    AssertF(this->effDev.cAxes == 0);
    AssertF(this->effTry.cAxes == 0);
    AssertF(this->effDev.rgdwAxes == this->effTry.rgdwAxes);
    AssertF(this->effTry.rgdwAxes == this->rgdwAxes);

    hres = CDIEff_MapDwords(this, peff->dwFlags, peff->cAxes,
                            this->effTry.rgdwAxes, peff->rgdwAxes,
                            DEVCO_AXIS | DEVCO_FFACTUATOR | DEVCO_TOID);
    if (FAILED(hres)) {
        RPF("ERROR %s: Invalid axis identifiers/offsets"
            "or axes are not all DIDFT_FFACTUATOR", s_szProc);
        goto done;
    }

    /*
     *  Make sure there are no dups in the axis list.
     *
     *  The outer loop starts at 1 because the 0'th axis
     *  can't possibly conflict with any others.
     */
    for (idw = 1; idw < peff->cAxes; idw++) {
        DWORD idwT;
        for (idwT = 0; idwT < idw; idwT++) {
            if (this->effTry.rgdwAxes[idw] == this->effTry.rgdwAxes[idwT]) {
                RPF("ERROR %s: arg %d: Duplicate axes in axis array",
                    s_szProc, iarg);
                hres = E_INVALIDARG;
                goto done;
            }
        }
    }

    this->effTry.cAxes = peff->cAxes;

done:;
    return hres;

}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | CDIEff | TryDirection |
 *
 *          Set information about the direction of an effect into the
 *          temporary buffer.
 *
 *          This is particularly gruesome, because we need to keep
 *          two sets of books: The values passed by the app (which
 *          we regurgitate back when queried) and the values passed
 *          to the driver.
 *
 *          We must keep two sets of books, because I just know
 *          that some apps are going to act up if the
 *          parameters they read back do not <y exactly> match
 *          the values they set in.  For example, they might
 *          read the value, subtract five, and write it back.
 *          Due to rounding, <y n> and <y n>-5 have the same
 *          value in the driver, so if we translated down and
 *          back, the value wouldn't change, and the app would
 *          get stuck in an infinite loop.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

#ifndef XDEBUG

#define CDIEff_TryDirection_(this, peff, z, iarg)                   \
       _CDIEff_TryDirection_(this, peff)                            \

#endif

#define CDIEff_TryDirection(this, peff, iarg)                       \
        CDIEff_TryDirection_(this, peff, s_szProc, iarg)            \

STDMETHODIMP
CDIEff_TryDirection_(PDE this, LPCDIEFFECT peff, LPCSTR s_szProc, int iarg)
{
    HRESULT hres;
    DWORD dieffRc;

    AssertF(CDIDev_InCrit(this->pdev));

    /*
     *  These should've been caught by validation.
     */
    AssertF(this->effTry.cAxes);
    AssertF(peff->cAxes == this->effTry.cAxes);
    AssertF(fLimpFF(peff->dwFlags & DIEFF_POLAR, peff->cAxes == 2));

    /*
     *  Translate the coordinates into device coordinates.
     */
    AssertF((this->dwCoords & ~DIEFF_COORDMASK) == 0);
    AssertF(this->dwCoords);

    this->effTry.rglDirection = this->rglDirTry;
    dieffRc = CDIEff_ConvertDirection(
                    this->effTry.cAxes,
                    this->rglDirTry, this->dwCoords,
                    peff->rglDirection, peff->dwFlags & DIEFF_COORDMASK);
    AssertF(dieffRc);

    this->effTry.dwFlags = (this->effTry.dwFlags & ~DIEFF_COORDMASK) | dieffRc;

    hres = S_OK;

    return hres;

}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method void | CDIEff | TryParameters |
 *
 *          Build the Try structure based on the new parameters.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          The original effect structure passed by the application.
 *
 *  @parm   DWORD | fl |
 *
 *          The <c DIEP_*> flags which specify what changed.
 *
 *****************************************************************************/

HRESULT INTERNAL
CDIEff_TryParameters(PDE this, LPCDIEFFECT peff, DWORD fl)
{
    HRESULT hres = S_OK;  
    EnterProcR(IDirectInputEffect::SetParameters, (_ "ppx", this, peff, fl));

    AssertF(this->lpvTSP == 0);

    /*
     *  Copy the current device parameters so we
     *  can modify the copy without damaging the original.
     */
    this->effTry = this->effDev;

    /*
     *  Install the appropriate effect parameters.
     */

    if (fl & DIEP_DURATION) {
        this->effTry.dwDuration = peff->dwDuration;
    }

    if (fl & DIEP_SAMPLEPERIOD) {
        this->effTry.dwSamplePeriod = peff->dwSamplePeriod;
    }

    if (fl & DIEP_GAIN) {
        this->effTry.dwGain = peff->dwGain;
    }

#if DIRECTINPUT_VERSION >= 0x0600
    if (fl & DIEP_STARTDELAY) {
        this->effTry.dwStartDelay = peff->dwStartDelay;
    }
#endif

    if (fl & DIEP_TRIGGERBUTTON) {
        hres = CDIEff_TryTriggerButton(this, peff, 1);
        if (FAILED(hres)) {
            goto done;
        }
    }

    if (fl & DIEP_TRIGGERREPEATINTERVAL) {
        this->effTry.dwTriggerRepeatInterval =
                                    peff->dwTriggerRepeatInterval;
    }

    if (fl & DIEP_TYPESPECIFICPARAMS) {
        this->effTry.cbTSP = peff->cbTSP;
        this->effTry.lpvTSP = peff->lpvTSP;

        /*
         *  Preallocate memory to hold the type-specific parameters
         *  to make sure we can proceed on success.
         */
        if (this->effDev.cbTSP != this->effTry.cbTSP) {
            hres = AllocCbPpv(this->effTry.cbTSP, &this->lpvTSP);
            if (FAILED(hres)) {
                goto done;
            }
        }

    }

    /*
     *  Must do axes before directions because directions
     *  depends on the number of axes.
     */

    if (fl & DIEP_AXES) {
        hres = CDIEff_TryAxis(this, peff, 1);
        if (FAILED(hres)) {
            goto done;
        }
    }

    if (fl & DIEP_DIRECTION) {
        hres = CDIEff_TryDirection(this, peff, 1);
        if (FAILED(hres)) {
            goto done;
        }
    }

    if (fl & DIEP_ENVELOPE) {
        this->effTry.lpEnvelope = peff->lpEnvelope;
    }

done:;
    ExitOleProc();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method void | CDIEff | SaveTry |
 *
 *          A Try'd effect worked.  Save its parameters in the
 *          driver parameter cache.
 *
 *  @cwrap  PDE | this
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          The original effect structure passed by the application.
 *
 *  @parm   DWORD | fl |
 *
 *          The <c DIEP_*> flags which specify what changed.
 *
 *****************************************************************************/

void INTERNAL
CDIEff_SaveTry(PDE this, LPCDIEFFECT peff, DWORD fl)
{

    /*
     *  For the easy stuff, just copy them blindly.
     *  It doesn't hurt to copy something that didn't change.
     */
    this->effDev.dwDuration              = this->effTry.dwDuration;
    this->effDev.dwSamplePeriod          = this->effTry.dwSamplePeriod;
    this->effDev.dwGain                  = this->effTry.dwGain;
    this->effDev.dwTriggerButton         = this->effTry.dwTriggerButton;
    this->effDev.dwTriggerRepeatInterval = this->effTry.dwTriggerRepeatInterval;
#if DIRECTINPUT_VERSION >= 0x0600
	this->effDev.dwStartDelay            = this->effTry.dwStartDelay;
#endif

    /*
     *  Axes count as "easy" because CDIEff_TryAxes put the
     *  axis info directly into this->rgdwAxes.
     */
    this->effDev.cAxes                   = this->effTry.cAxes;

    /*
     *  Now the hard parts: The things that require
     *  memory allocation or block copying.
     */

    if (fl & DIEP_TYPESPECIFICPARAMS) {
        if (this->effDev.cbTSP == this->effTry.cbTSP) {
            AssertF(this->lpvTSP == 0);
        } else {
            AssertF(this->lpvTSP);
            this->effDev.cbTSP = this->effTry.cbTSP;
            FreePpv(&this->effDev.lpvTSP);
            this->effDev.lpvTSP = this->lpvTSP;
            this->lpvTSP = 0;
        }
        CopyMemory(this->effDev.lpvTSP, this->effTry.lpvTSP,
                   this->effTry.cbTSP);
    }

    if (fl & DIEP_DIRECTION) {
        /*
         *  Save the app coordinate and the coordinate system into our cache.
         */
        this->dwDirFlags = peff->dwFlags & DIEFF_COORDMASK;
        CopyMemory(this->rglDirApp, peff->rglDirection,
                   cbCdw(this->effDev.cAxes));

        /*
         *  And propagate the Try'd coordinates into the Drv coordinates.
         */
        this->effDev.dwFlags= this->effTry.dwFlags;
        CopyMemory(this->rglDirDev, this->rglDirTry, cbX(this->rglDirTry));
    }

    if (fl & DIEP_ENVELOPE) {
        if (this->effTry.lpEnvelope) {
            this->effDev.lpEnvelope = &this->env;
            this->env = *this->effTry.lpEnvelope;
        } else {
            this->effDev.lpEnvelope = 0;
        }
    }

}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | SetParameters |
 *
 *          Set information about an effect.
 *
 *          It is valid to update the parameters of an effect while
 *          it is playing.  The new parameters take effect immediately
 *          upon download if the device supports dynamic updating of effect
 *          parameters.  The <mf IDirectInputEffect::SetParameters>
 *          method automatically downloads the effect, but this behavior
 *          can be suppressed by setting the <c DIEP_NODOWNLOAD> flag.
 *
 *          If automatic download has been suppressed, then you can
 *          manually download the effect by invoking the
 *          <mf IDirectInputEffect::Download> method.
 *
 *          If the effect is playing while the parameters are changed,
 *          then the new parameters take effect as if they were the
 *          parameters when the effect started.
 *
 *          For example, suppose a periodic effect with a duration
 *          of three seconds is started.
 *          After two seconds, the direction of the effect is changed.
 *          The effect will then continue for one additional second
 *          in the new direction.  The envelope, phase, amplitude,
 *          and other parameters of the effect continue smoothly
 *          as if the direction had not changed.
 *
 *          In the same scenario, if after two seconds, the duration
 *          of the effect were changed to 1.5 seconds, then the effect
 *          would stop, because two seconds have already elapsed from
 *          the beginning of effect playback.
 *
 *          Two additional flags control the download behavior.
 *          The <c DIEP_START> flag indicates that the effect should
 *          be started (or restarted if it is currently playing) after
 *          the parameters are updated.  By default, the play state
 *          of the effect is not altered.
 *
 *          Normally, if the driver cannot update the parameters
 *          of a playing effect, it is permitted to stop the effect,
 *          update the parameters, and then restart the effect.
 *          Passing the <c DIEP_NORESTART> flag suppresses this
 *          behavior.  If the driver cannot update the parameters
 *          of an effect while it is playing, the error code
 *          <c DIERR_EFFECTPLAYING> is returned and the parameters
 *          are not updated.
 *
 *          To summarize the behavior of the three flags that control
 *          download and playback behavior:
 *
 *          If <c DIEP_NODOWNLOAD> is set, then the effect parameters
 *          are updated but not downloaded to the device.
 *
 *          Otherwise, the <c DIEP_NODOWNLOAD> flag is clear.
 *
 *          If the <c DIEP_START> flag is set, then the effect
 *          parameters are updated and downloaded to the device,
 *          and the effect is started,
 *          as if the <mf IDirectInputEffect::Start> method were
 *          called.  Combining the update with <c DIEP_START> is
 *          slightly faster than calling
 *          <mf IDirectInputEffect::Start> separately, because
 *          it requires less information to be transmitted to the
 *          device.
 *
 *          Otherwise, both the <c DIEP_NODOWNLOAD> and
 *          <c DIEP_START> flags are clear.
 *
 *          If the effect is not playing, then the parameters
 *          are updated and downloaded to the device.
 *
 *          Otherwise, both the <c DIEP_NODOWNLOAD> and
 *          <c DIEP_START> flags are clear, and the effect is
 *          already playing.
 *
 *          If the parameters of the effect can be updated
 *          "on the fly", then the update is so performed.
 *
 *          Otherwise, both the <c DIEP_NODOWNLOAD> and
 *          <c DIEP_START> flags are clear, and the effect is
 *          already playing, and the parameters cannot be updated
 *          while the effect is playing.
 *
 *          If the <c DIEP_NORESTART> flag is set, then the
 *          error code <c DIERR_EFFECTPLAYING> is returned.
 *
 *          Otherwise, all three of the flags
 *          <c DIEP_NODOWNLOAD>, <c DIEP_START> and
 *          <c DIEP_NORESTART> are clear, and the effect is
 *          already playing, and the parameters cannot be
 *          updated while the effect is playing.
 *
 *          The effect is stopped, the parameters updated, and
 *          the effect is restarted.  The return code is
 *          <c DI_EFFECTRESTARTED>.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   LPCDIEFFECT | peff |
 *
 *          Structure that contains effect information.
 *          The <e DIEFFECT.dwSize> field must be filled in by
 *          the application before calling this function, as well
 *          as any fields specified by corresponding bits in
 *          the <p dwFlags> parameter.
 *
 *  @parm   DWORD | dwFlags |
 *
 *          Zero or more <c DIEP_*> flags specifying which
 *          portions of the effect information is to be set
 *          and how the downloading of the effect parameters
 *          should be handled.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DI_NOTDOWNLOADED>: The parameters of the effect were
 *          successfully
 *          updated, but the effect could not be downloaded because
 *          the associated device is not acquired in exclusive mode.
 *          Note that this is a success code, because the
 *          parameters were successfully updated.
 *
 *          <c DI_TRUNCATED>: The parameters of the effect were
 *          successfully updated,
 *          but some of the effect parameters were
 *          beyond the capabilities of the device and were truncated
 *          to the nearest valid value.
 *          Note that this is a success code, because the
 *          parameters were successfully updated.
 *
 *          <c DI_EFFECTRESTARTED>: The parameters of the effect
 *          were successfully updated, and the effect was restarted.
 *          Note that this is a success code, because the
 *          parameters were successfully updated.
 *
 *          <c DI_TRUNCATEDANDRESTARTED>: The parameters of the effect
 *          were successfully updated, but some of the effect parameters
 *          were truncated, and the effect was restarted.  This code
 *          combines <c DI_TRUNCATED> and <c DI_EFFECTRESTARTED>.
 *          Note that this is a success code, because the
 *          parameters were successfully updated.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not been initialized.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *          <c DIERR_EFFECTPLAYING>: The parameters were not updated
 *          because
 *          the device does not support updating an effect while
 *          it is still playing, and the <c DIEP_NORESTART> flag was
 *          passed, prohibiting the driver from stopping the effect,
 *          updating its parameters, and restarting it.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_SetParameters(PDIE pdie, LPCDIEFFECT peff, DWORD fl)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::SetParameters, (_ "ppx", pdie, peff, fl));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
#if DIRECTINPUT_VERSION >= 0x0600
        SUCCEEDED(hres = hresFullValidReadPxCb2(peff,
                                                DIEFFECT_DX6,
                                                DIEFFECT_DX5, 1)) &&
        SUCCEEDED(hres = hresFullValidFl(fl, ((peff->dwSize == cbX(DIEFFECT_DX6)) 
                                              ? DIEP_SETVALID : DIEP_SETVALID_DX5 ), 2))) {
#else
        SUCCEEDED(hres = hresFullValidReadPxCb(peff, DIEFFECT, 1)) &&
        SUCCEEDED(hres = hresFullValidFl(fl, DIEP_SETVALID_DX5, 2))) {
#endif

        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        if (SUCCEEDED(hres = hresFullValidPeff(this, peff, fl, 1))) {

            BOOL fChangeEmulatedStartDelay = FALSE;
    
            /*
             *  Note that if fl == 0 (or nearly so),
             *  TryParameters doesn't do anything,
             *  albeit rather inefficiently.
             */
            hres = CDIEff_TryParameters(this, peff, fl);
            if (FAILED(hres)) {
                goto done;
            }

			/*
			 * Special case for DIEP_STARTDELAY.
			 */
			if (fl & DIEP_STARTDELAY)
			{
				if (this->dEffAttributes.dwStaticParams & DIEP_STARTDELAY)
				{
					/*
					 * Driver supports it, so don't worry.
					 */
					;
				}
				else
				{
					/*
					 * Driver doesn't support it.
					 * Take start delay out...
					 */
					fl &= ~(DIEP_STARTDELAY);
				    this->diepUnset &= ~(DIEP_STARTDELAY);

                    /*
                     * ...but remember that we may need to do something
                     */
                    fChangeEmulatedStartDelay = ( this->effDev.dwStartDelay != this->effTry.dwStartDelay );
					if (fl == 0)
					{
						hres = DI_OK;
						goto save;
					}

				}


			}

            /*
             *  Now pass the effTry to the device driver for
             *  final validation.
             *
             *  Passing fl=0 is a really slow way of downloading
             *  the effect, except that we return DI_DOWNLOADSKIPPED
             *  instead of an error code if the device is not exclusive
             *  acquired.
             *
             *  Passing fl=DIEP_NODOWNLOAD is a really slow NOP.
             *
             *  Note that inability to download due to lack of
             *  proper acquisition is not an error, merely a warning.
             */
            hres = CDIEff_DownloadWorker_(this, &this->effTry, fl, 0);
            AssertF(hres != DIERR_NOTDOWNLOADED);

            /*
             *  If the driver approves, then make the changes permanent.
             *  but first a check on the emulated driver
             */
			save:;

            if( SUCCEEDED(hres) ) 
            {
                if( fChangeEmulatedStartDelay )
                {
                    /*
                     * The start delay for parameter has been changed, so 
                     * any future iteration is OK also the driver has 
                     * SUCCEEDED any other changes.
                     */
                    if( this->dwMessage != EFF_PLAY )
                    {
                        /*
                         * We're not in the delay, so declare everything OK.
                         */
                    }
                    else
                    {
                        /*
                         * If the download was skipped don't bother.
                         */
                        if( hres != DI_DOWNLOADSKIPPED )
                        {
                            if( fl & DIEP_NORESTART )
                            {
                                /*
                                 * We don't support changing the delay during the 
                                 * delay.  Since the driver has already had its 
                                 * parameters changed, only fail this if the 
                                 * delay was the only change requested.
                                 */
                                if( fl == 0 )
                                {
                                    hres = DIERR_EFFECTPLAYING;
                                }
                            }
                            else
                            {
                                /*
                                 * Since we don't support modifying the delay 
                                 * whilst we're in it, restart with the new 
                                 * delay.
                                 * If we were being really smart, we could 
                                 * try to adjust the delay without restarting.
                                 */
                                if( this->hEventDelete && this->hEventGeneral )
                                {
                                    this->dwMessage = EFF_PLAY;
                                    ResetEvent(this->hEventGeneral);
                                    SetEvent(this->hEventGeneral);
                                    if( ( hres & ~DI_TRUNCATEDANDRESTARTED ) == 0 ) 
                                    {
                                        hres |= DI_EFFECTRESTARTED;
                                    }
                                    else if( hres == DI_NOEFFECT )
                                    {
                                        hres = DI_EFFECTRESTARTED;
                                    }
                                }
                                else
                                {
                                    AssertF( !"Effect synchronization event(s) NULL" );
                                }
                            }
                        }
                    }
                }
                else
                {
                    /*
                     *  If there was no change to an emulated start delay then 
                     *  the result we have is already what we need.
                     */
                }
            }

            if (SUCCEEDED(hres)) {
                this->diepUnset &= ~fl;             /* No longer unset */

                /*
                 *  If we didn't download, then the parameters are
                 *  dirty and need to be downloaded later.
                 */
                if (hres == DI_DOWNLOADSKIPPED) {
                    this->diepDirty |= (fl & DIEP_ALLPARAMS);
                }

                CDIEff_SaveTry(this, peff, fl);     /* Save permanently */

            }


        done:;
            FreePpv(&this->lpvTSP);

        }

        CDIEff_LeaveCrit(this);

    }

    ExitOleProc();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | RealStart |
 *
 *          Actually begin playing an effect.  The parent device must
 *          be acquired.
 *
 *          If the effect is already playing, then it is restarted
 *          from the beginning.
 *
 *          If the effect has not been downloaded or has been
 *          modified since its last download, then it will be
 *          downloaded before being started.  This default
 *          behavior can be suppressed by passing the
 *          <c DIES_NODOWNLOAD> flag.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   DWORD | dwIterations |
 *
 *          Number of times to play the effect in sequence.
 *          The envelope is re-articulated with each iteration.
 *
 *          To play the effect exactly once, pass 1.
 *
 *          To play the effect repeatedly until explicitly stopped,
 *          pass <c INFINITE>.
 *
 *          To play the effect until explicitly stopped without
 *          re-articulating the envelope, modify the effect
 *          parameters via <mf IDirectInputEffect::SetParameters>
 *          and change its <e DIEFFECT.dwDuration> to <c INFINITE>.
 *
 *  @parm   DWORD | dwFlags |
 *
 *          Flags that describe how the effect should be played
 *          by the device.  It can be zero or more of the
 *          <c DIES_*> flags.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not been initialized or no effect parameters have been
 *          set.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_RealStart(PDIE pdie, DWORD dwcLoop, DWORD fl)
{
	HRESULT hres;
    EnterProcR(IDirectInputEffect::Start, (_ "ppx", pdie, dwcLoop, fl));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresFullValidFl(fl, DIES_VALID, 2))) {

        PDE this = _thisPvNm(pdie, def);
		
        if( SUCCEEDED( hres= (IsBadReadPtr(this, cbX(this))) ? E_POINTER : S_OK ) )
        {
            CDIEff_EnterCrit(this);
    
            if (SUCCEEDED(hres = CDIEff_CanAccess(this))) {
    
                if (fl & DIES_NODOWNLOAD) {
                    /*
                     *  App wants fine control.  Let him have it.
                     */
                    hres = IDirectInputEffectShepherd_StartEffect(
                              this->pes, &this->sh, fl & DIES_DRIVER, dwcLoop);
                } else {
                    /*
                     *  App wants us to do the work.  First thing to do
                     *  is see if the effect needs to be downloaded.
                     *
                     *  SyncShepHandle checks if the effect is downloaded.
                     */
                    hres = CDIEff_SyncShepHandle(this);
    
                    if (this->diepDirty == 0 && this->sh.dwEffect) {
                        /*
                         *  Effect is clean and downloaded.
                         *  Just start it normally.
                         */
                        hres = IDirectInputEffectShepherd_StartEffect(
                                    this->pes, &this->sh,
                                    fl & DIES_DRIVER, dwcLoop);
    
                    } else {
                        /*
                         *  Effect needs to be downloaded.  We can
                         *  optimize it if no special flags are set
                         *  and the loop count is exactly unity.
                         */
                        if (fl == 0 && dwcLoop == 1) {
                            hres = CDIEff_DownloadWorker(this, &this->effDev,
                                                         DIEP_START);
                        } else {
                            /*
                             *  Cannot optimize; must do separate download
                             *  followed by Start.
                             */
                            hres = CDIEff_DownloadWorker(this, &this->effDev, 0);
                            if (SUCCEEDED(hres)) {
                                hres = IDirectInputEffectShepherd_StartEffect(
                                            this->pes, &this->sh,
                                            fl & DIES_DRIVER, dwcLoop);
                            }
                        }
                    }
                }
            }
    
            CDIEff_LeaveCrit(this); 
        }
    }

    ExitOleProcR();
    return hres;
}


/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method DWORD | WINAPI | CDIEff_ThreadProc |
 *
 *			Used to simulate dwStartDelay for drivers that do not support it.
 *          Begin playing an effect that has already been downloaded.  The parent device must
 *          be acquired.
 *
 *          If the effect is already playing, then it is restarted
 *          from the beginning.
 *
 *          If the effect has not been downloaded or has been
 *          modified since its last download, then it will be
 *          downloaded before being started.  This default
 *          behavior can be suppressed by passing the
 *          <c DIES_NODOWNLOAD> flag.
 *	
 *			After starting the effect, kills the timer whose event activated CDIEff_TimerProc
 *
 *
 *  @parm   LPVOID | lpParameter |
 *
 *			LPDIRECTINPUTEFFECT pointer.
 *
 *  @returns
 *
 *         0 if succeeded in starting the effect, or if the effect has been deleted by the app.
 *         -1 otherwise
 *
 *****************************************************************************/

 DWORD WINAPI CDIEff_ThreadProc(LPVOID lpParameter)
 {

	LPDIRECTINPUTEFFECT pdie = (LPDIRECTINPUTEFFECT) lpParameter;

	HRESULT hres = E_FAIL;
	DWORD dwWait;
	HANDLE hArray[2];
	BOOL startCalled = FALSE;

    PDE this = _thisPvNm(pdie, def);
    
    if( SUCCEEDED( hres= (IsBadReadPtr(this, cbX(this))) ? E_POINTER : S_OK ) )
    {
        if( this->hEventDelete != NULL && this->hEventThreadDead != NULL ) 
        {
        	hArray[0] = this->hEventDelete;
        	hArray[1] = this->hEventGeneral;
        
            ResetEvent( this->hEventThreadDead );
    
        	/*
        	 * Wait till the timeout expires, or till one of the events happens -- 
        	 * the effect is deleted by the app (hEventDelete) or the effect is started (hEventStart),
        	 * or the effect is stopped (hEventStop).
        	 */
        
            dwWait = WAIT_TIMEOUT; 
            while (dwWait != WAIT_OBJECT_0 && dwWait != WAIT_FAILED)
            {
                if (dwWait == WAIT_TIMEOUT) 
                {
                    if (startCalled)
                    {
                        /* 
                         * Start have been called, and timeout has expired.
                         * Start the effect. And wait again.
                         */
                        hres = CDIEff_RealStart(pdie, this->dwcLoop, this->dwFlags);
                        startCalled = FALSE;
                        this->dwMessage = EFF_DEFAULT;
                    }
    
                }
    
                else
                {
                    if (dwWait == (WAIT_OBJECT_0 + 1))
                    {
                        /* 
                         * App called Start on the effect.
                         * Set flag  and start waiting anew.
                         */
                        if (this->dwMessage == EFF_PLAY)
                        {
                            if ((this->effDev).dwStartDelay/1000 == 0)
                            {
                                /*
                                 * If time delay is 0 ms, start immediately.
                                 */
                                hres = CDIEff_RealStart(pdie, this->dwcLoop, this->dwFlags);
                                startCalled = FALSE;
                                this->dwMessage = EFF_DEFAULT;
                            }
    
                            else
                            {
                                startCalled = TRUE;
                            }
                        }
                        else
                        {
                            if (this->dwMessage == EFF_STOP)
                            {
                                startCalled = FALSE;
                                this->dwMessage = EFF_DEFAULT;
                            }
                        }
                        
                        ResetEvent(this->hEventGeneral);
                    }
    
                }
    
    
                /*
                 * And wait again.
                 */
                    
                if (startCalled == TRUE) {
                    dwWait = WaitForMultipleObjects(2, hArray, FALSE, (this->effDev).dwStartDelay/1000);
                } else {
                    dwWait = WaitForMultipleObjects(2, hArray, FALSE, INFINITE);
                }
            }
            
            SetEvent( this->hEventThreadDead );
        }

        /* 
         * App has deleted the effect.
         * Exit.
         */

        hres = DI_OK;
    	
    }

	if (SUCCEEDED(hres))
		return 0;
	else
		return -1;
 }


/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Start |
 *
 *          Begin playing an effect.  The parent device must
 *          be acquired.
 *
 *          If the effect is already playing, then it is restarted
 *          from the beginning.
 *
 *          If the effect has not been downloaded or has been
 *          modified since its last download, then it will be
 *          downloaded before being started.  This default
 *          behavior can be suppressed by passing the
 *          <c DIES_NODOWNLOAD> flag.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   DWORD | dwIterations |
 *
 *          Number of times to play the effect in sequence.
 *          The envelope is re-articulated with each iteration.
 *
 *          To play the effect exactly once, pass 1.
 *
 *          To play the effect repeatedly until explicitly stopped,
 *          pass <c INFINITE>.
 *
 *          To play the effect until explicitly stopped without
 *          re-articulating the envelope, modify the effect
 *          parameters via <mf IDirectInputEffect::SetParameters>
 *          and change its <e DIEFFECT.dwDuration> to <c INFINITE>.
 *
 *  @parm   DWORD | dwFlags |
 *
 *          Flags that describe how the effect should be played
 *          by the device.  It can be zero or more of the
 *          <c DIES_*> flags.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not been initialized or no effect parameters have been
 *          set.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Start(PDIE pdie, DWORD dwcLoop, DWORD fl)
{

	HRESULT hres;
	EnterProcR(IDirectInputEffect::Start, (_ "ppx", pdie, dwcLoop, fl));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresFullValidFl(fl, DIES_VALID, 2))) {

        PDE this = _thisPvNm(pdie, def);

        if( SUCCEEDED( hres= (IsBadReadPtr(this, cbX(this))) ? E_POINTER : S_OK ) )
        {
            CDIEff_EnterCrit(this);
        
            if (SUCCEEDED(hres = CDIEff_CanAccess(this))) {
        
                this->dwcLoop = dwcLoop;
                this->dwFlags = fl;
        
                if (this->hEventDelete == NULL)
                    hres = CDIEff_RealStart(pdie, dwcLoop, fl);
                else 
                {
                    /* 
                     * Activate the thread's waiting period
                     */
                    hres = CDIEff_DownloadWorker(this, &this->effDev, 0);
                    if (this->hEventGeneral != NULL)
                    {
                        this->dwMessage = EFF_PLAY;
                        ResetEvent(this->hEventGeneral);
                        SetEvent(this->hEventGeneral);
                    }
                    
                }	
        
            }
        
            CDIEff_LeaveCrit(this);
        }
	}

	ExitOleProcR();
    return hres;

}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Stop |
 *
 *          Stop playing an effect.  The parent device must
 *          be acquired.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not been initialized or no effect parameters have been
 *          set.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Stop(PDIE pdie)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::Stop, (_ "p", pdie));

    if (SUCCEEDED(hres = hresPv(pdie))) {

        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        if (SUCCEEDED(hres = CDIEff_CanAccess(this))) {
            hres = IDirectInputEffectShepherd_StopEffect(this->pes, &this->sh);
        }

		if (this->hEventGeneral != NULL)
		{
			this->dwMessage = EFF_STOP;
			ResetEvent(this->hEventGeneral);
			SetEvent(this->hEventGeneral);
		}

        CDIEff_LeaveCrit(this);
    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | GetEffectStatus |
 *
 *          Retrieves the status of an effect.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   LPDWORD | pdwFlags |
 *
 *          Receives the status flags for the effect.  It may
 *          consist of zero or more <c DIEGES_*> flag values.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not been initialized or no effect parameters have been
 *          set.
 *
 *          <c DIERR_INVALIDPARAM> = <c E_INVALIDARG>:  At least one
 *          of the parameters is invalid.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_GetEffectStatus(PDIE pdie, LPDWORD pdwOut)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::Stop, (_ "p", pdie));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresFullValidPcbOut(pdwOut, cbX(*pdwOut), 1))) {

        PDE this = _thisPvNm(pdie, def);

        CAssertF(DEV_STS_EFFECT_RUNNING == DIEGES_PLAYING);

        CDIEff_EnterCrit(this);

        if (SUCCEEDED(hres = CDIEff_CanAccess(this))) {

			/*
			 * Check the dwMessage first -- 
			 * if it says PLAYING, report DIEGES_PLAYING
			 */
			if (this->dwMessage == EFF_PLAY)
			{
				*pdwOut = DIEGES_PLAYING;
				hres = DI_OK;
			}
			else
			{
				hres = IDirectInputEffectShepherd_GetEffectStatus(
							this->pes, &this->sh, pdwOut);
			}
        }

        CDIEff_LeaveCrit(this);
    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Escape |
 *
 *          Send a hardware-specific command to the driver.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   LPDIEFFESCAPE | pesc |
 *
 *          Pointer to a <t DIEFFESCAPE> structure which describes
 *          the command to be sent.  On success, the
 *          <e DIEFFESCAPE.cbOutBuffer> field contains the number
 *          of bytes of the output buffer actually used.
 *
 *  @returns
 *
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_NOTDOWNLOADED>:  The effect is not downloaded.
 *
 *          <c DIERR_NOTINITIALIZED>: The <i IDirectInputEffect> object
 *          has not yet been <mf IDirectInputEffect::Initialize>d.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_Escape(PDIE pdie, LPDIEFFESCAPE pesc)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::Escape, (_ "p", pdie));

    /*
     *  The output buffer is NoScramble because some people like
     *  to pass overlapping in and out buffers.
     */
    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresFullValidPesc(pesc, 1))) {
        PDE this = _thisPvNm(pdie, def);

        CDIEff_EnterCrit(this);

        /*
         *  Download the effect if it isn't downloaded yet,
         *  so we have a valid effect to Escape on.
         */
        hres = CDIEff_DownloadWorker(this, &this->effDev, 0);
        if (SUCCEEDED(hres)) {
            hres = IDirectInputEffectShepherd_Escape(
                        this->pes, &this->sh, pesc);
        } else {
            hres = DIERR_NOTDOWNLOADED;
        }

        CDIEff_LeaveCrit(this);
    }

    ExitOleProcR();
    return hres;
}

/*****************************************************************************
 *
 *  @doc    EXTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Initialize |
 *
 *          Initialize a DirectInputEffect object.
 *
 *          Note that if this method fails, the underlying object should
 *          be considered to be an an indeterminate state and needs to
 *          be reinitialized before it can be subsequently used.
 *
 *          The <mf IDirectInputDevice::CreateEffect> method automatically
 *          initializes the device after creating it.  Applications
 *          normally do not need to call this function.
 *
 *  @cwrap  LPDIRECTINPUTEFFECT | lpDirectInputEffect
 *
 *  @parm   IN HINSTANCE | hinst |
 *
 *          Instance handle of the application or DLL that is creating
 *          the DirectInputEffect object.
 *
 *          See the section titled "Initialization and Versions"
 *          for more information.
 *
 *  @parm   DWORD | dwVersion |
 *
 *          Version number of the dinput.h header file that was used.
 *
 *          See the section titled "Initialization and Versions"
 *          for more information.
 *
 *  @parm   IN REFGUID | rguid |
 *
 *          Identifies the effect for which the interface
 *          should be associated.
 *          The <mf IDirectInputDevice::EnumEffects> method
 *          can be used to determine which effect GUIDs are supported by
 *          the device.
 *
 *  @returns
 *          Returns a COM error code.  The following error codes are
 *          intended to be illustrative and not necessarily comprehensive.
 *
 *          <c DI_OK> = <c S_OK>: The operation completed successfully.
 *
 *          <c DIERR_DEVICENOTREG>: The effect GUID does not exist
 *          on the current device.
 *
 *****************************************************************************/

#pragma BEGIN_CONST_DATA

TSDPROC c_rgtsd[] = {
    CDIEff_IsValidConstantTsd,      /* DIEFT_CONSTANTFORCE  */
    CDIEff_IsValidRampTsd,          /* DIEFT_RAMPFORCE      */
    CDIEff_IsValidPeriodicTsd,      /* DIEFT_PERIODIC       */
    CDIEff_IsValidConditionTsd,     /* DIEFT_CONDITION      */
    CDIEff_IsValidCustomForceTsd,   /* DIEFT_CUSTOMFORCE    */
#if DIRECTINPUT_VERSION >= 0x0800
    CDIEff_IsValidRandomTsd,        /* DIEFT_RANDOM         */
    CDIEff_IsValidAbsoluteTsd,      /* DIEFT_ABSOLUTE       */
    CDIEff_IsValidBumpForceTsd,     /* DIEFT_BUMPFORCE      */
    CDIEff_IsValidConditionExTsd,   /* DIEFT_CONDITIONEX    */
#endif /* DIRECTINPUT_VERSION >= 0x0800 */
};

STDMETHODIMP
CDIEff_Initialize(PDIE pdie, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid)
{

	HRESULT hres;
    EnterProcR(IDirectInputEffect::Initialize,
               (_ "pxxG", pdie, hinst, dwVersion, rguid));

    if (SUCCEEDED(hres = hresPv(pdie)) &&
        SUCCEEDED(hres = hresValidInstanceVer(hinst, dwVersion)) &&
        SUCCEEDED(hres = hresFullValidGuid(rguid, 1))) {
        PDE this = _thisPv(pdie);
        EFFECTMAPINFO emi;

        AssertF(this->pes);

        /*
         *  Don't let somebody mess with the effect while we're
         *  resetting it.
         */
        CDIEff_EnterCrit(this);

        if (SUCCEEDED(hres = CDIDev_FindEffectGUID(this->pdev, rguid,
                                                   &emi, 3)) &&
            SUCCEEDED(hres = CDIEff_Reset(this))) {

            /*
             *  ISSUE-2001/03/29-timgill Need to check for actual hardware FF effect support
             */

			/*
			 * Initialize dEffAttributes 
			 */
            this->fInitialized = 1;
            this->dEffAttributes = emi.attr;
            this->guid = *rguid;

		
			/* 
			 * Check if the app is using DX6 or above structure.
			 * If not, no dwStartDelay is being requested by the app.
			 * 
			 * Check if the driver supports dwStartDelay.
			 * If it does, no need for us to do anything in that respect.
			 */

			if ((dwVersion < 0x0600)  ||
				((this->dEffAttributes).dwStaticParams & DIEP_STARTDELAY))
			{
				/*
				 * No need to emulate dwStartDelay.
				 */
				;
			}

			else
			{
					/*
					 * Driver doesn't support start delay.
					 * Start a thread that will emulate dwStartDelay.
					 */
	
					DWORD dwThreadId;
					HANDLE hThread;

					this->hEventDelete = CreateEvent(NULL, TRUE, FALSE, NULL);
					this->hEventThreadDead = CreateEvent(NULL, TRUE, FALSE, NULL);

					hThread = CreateThread(NULL, 0, CDIEff_ThreadProc, (LPVOID)pdie, 0, &dwThreadId);
					if (hThread == NULL)
					{
						/* Failed to create the thread.
						 * Clean up all our preparations.
						 */
						CloseHandle(this->hEventDelete);
						this->hEventDelete = NULL;
						CloseHandle(this->hEventThreadDead);
						this->hEventThreadDead = NULL;
						hres = hresLe(GetLastError());		
					}

					else
					{
						/*
						 * Create an event to signal effect started or stopped
						 */
						this->hEventGeneral = CreateEvent(NULL, TRUE, FALSE, NULL);
					}
			}


            this->dwCoords = emi.attr.dwCoords & DIEFF_COORDMASK;
            AssertF(this->dwCoords);


            /*
             *  Note, we allow non-hardware specific types that are not 
             *  recognized to pass through untested.  This effects to be run 
             *  from a device which has newer effects than this version of 
             *  DInput can check.  However if this DInput recognizes the 
             *  effect type, it will be checked, even if the application was 
             *  written for a version that could not check it.
             */
            if (fInOrder(DIEFT_PREDEFMIN, DIEFT_GETTYPE(emi.attr.dwEffType),
                         DIEFT_PREDEFMAX)) {
                this->hresValidTsd = c_rgtsd[
                            DIEFT_GETTYPE(emi.attr.dwEffType) -
                                                        DIEFT_PREDEFMIN];
            } else {
                this->hresValidTsd = CDIEff_IsValidUnknownTsd;
            }

            hres = S_OK;

        }

        CDIEff_LeaveCrit(this);
    }

    ExitOleProcR();
    return hres;


}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | Init |
 *
 *          Initialize the internal parts of the DirectInputEffect object.
 *
 *  @parm   LPDIRECTINPUTEFFECTSHEPHERD | pes |
 *
 *          The shepherd that lets us talk to the driver.
 *
 *****************************************************************************/

HRESULT INLINE
CDIEff_Init(struct CDIDev *pdev, LPDIRECTINPUTEFFECTSHEPHERD pes, PDE this)
{
    HRESULT hres;

    /*
     *  The critical section must be the very first thing we do,
     *  because only Finalize checks for its existence.
     *
     *  (We might be finalized without being initialized if the user
     *  passed a bogus interface to CDIEff_New.)
     */
    this->pdev = pdev;
    Common_Hold(this->pdev);

    this->pes = pes;
    OLE_AddRef(this->pes);

    hres = CDIDev_NotifyCreateEffect(this->pdev, this);
    if (SUCCEEDED(hres)) {
        this->fDadNotified = 1;
    }

    return hres;
}

/*****************************************************************************
 *
 *  @doc    INTERNAL
 *
 *  @method HRESULT | IDirectInputEffect | New |
 *
 *          Create a new DirectInputEffect object, uninitialized.
 *
 *  @parm   IN struct CDIDev * | pdd |
 *
 *          Parent device, which we keep a <f Common_Hold> on.
 *
 *  @parm   LPDIRECTINPUTEFFECTSHEPHERD | pes |
 *
 *          The shepherd that lets us talk to the driver.
 *
 *  @parm   IN PUNK | punkOuter |
 *
 *          Controlling unknown for aggregation.
 *
 *  @parm   IN RIID | riid |
 *
 *          Desired interface to new object.
 *
 *  @parm   OUT PPV | ppvObj |
 *
 *          Output pointer for new object.
 *
 *****************************************************************************/

STDMETHODIMP
CDIEff_New(struct CDIDev *pdev, LPDIRECTINPUTEFFECTSHEPHERD pes,
           PUNK punkOuter, RIID riid, PPV ppvObj)
{
    HRESULT hres;
    EnterProcR(IDirectInputEffect::<constructor>,
               (_ "ppGp", pdev, pes, riid, punkOuter));

	if (SUCCEEDED(hres = hresFullValidPcbOut(ppvObj, cbX(*ppvObj), 5)))
	{
		LPVOID pvTry = NULL;
		hres = Common_NewRiid(CDIEff, punkOuter, riid, &pvTry);

		if (SUCCEEDED(hres)) {
			PDE this = _thisPv(pvTry);
			hres = CDIEff_Init(pdev, pes, this);
			if (SUCCEEDED(hres)) {
				*ppvObj = pvTry;
			} else {
				Invoke_Release(&pvTry);
				*ppvObj = NULL;
			}
		}
	}

    ExitOleProcPpvR(ppvObj);
    return hres;
}

/*****************************************************************************
 *
 *      The long-awaited vtbls and templates
 *
 *****************************************************************************/

#pragma BEGIN_CONST_DATA

#define CDIEff_Signature        0x20464643      /* "EFF " */

Primary_Interface_Begin(CDIEff, IDirectInputEffect)
    CDIEff_Initialize,
    CDIEff_GetEffectGuid,
    CDIEff_GetParameters,
    CDIEff_SetParameters,
    CDIEff_Start,
    CDIEff_Stop,
    CDIEff_GetEffectStatus,
    CDIEff_Download,
    CDIEff_Unload,
    CDIEff_Escape,
Primary_Interface_End(CDIEff, IDirectInputEffect)

#endif