git.oblomov.eu Git - wine/blob - dlls/dinput/effect_linuxinput.c

   1 /*              DirectInput Linux Event Device Effect
   2  *
   3  * Copyright 2005 Daniel Remenak
   4  *
   5  * Thanks to Google's Summer of Code Program (2005)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
  25
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #ifdef HAVE_LINUX_INPUT_H
  29 #  include <linux/input.h>
  30 #  undef SW_MAX
  31 #endif
  32 #include <errno.h>
  33 #ifdef HAVE_UNISTD_H
  34 #  include <unistd.h>
  35 #endif
  36 #include <math.h>
  37 #include "wine/debug.h"
  38 #include "wine/unicode.h"
  39 #include "windef.h"
  40 #include "winbase.h"
  41 #include "winerror.h"
  42 #include "dinput.h"
  43
  44 #include "device_private.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(dinput);
  47
  48 static const IDirectInputEffectVtbl LinuxInputEffectVtbl;
  49 typedef struct LinuxInputEffectImpl LinuxInputEffectImpl;
  50 struct LinuxInputEffectImpl
  51 {
  52     const void *lpVtbl;
  53     LONG        ref;
  54     GUID        guid;
  55
  56     struct ff_effect    effect; /* Effect data */
  57     int                 gain;   /* Effect gain */
  58     int                 first_axis_is_x;
  59     int*                fd;     /* Parent device */
  60     struct list        *entry;  /* Entry into the parent's list of effects */
  61 };
  62
  63
  64 /******************************************************************************
  65  *      DirectInputEffect Functional Helper
  66  */
  67
  68 static DWORD _typeFromGUID(REFGUID guid)
  69 {
  70     if (IsEqualGUID(guid, &GUID_ConstantForce)) {
  71         return DIEFT_CONSTANTFORCE;
  72     } else if (IsEqualGUID(guid, &GUID_Square)
  73             || IsEqualGUID(guid, &GUID_Sine)
  74             || IsEqualGUID(guid, &GUID_Triangle)
  75             || IsEqualGUID(guid, &GUID_SawtoothUp)
  76             || IsEqualGUID(guid, &GUID_SawtoothDown)) {
  77         return DIEFT_PERIODIC;
  78     } else if (IsEqualGUID(guid, &GUID_RampForce)) {
  79         return DIEFT_RAMPFORCE;
  80     } else if (IsEqualGUID(guid, &GUID_Spring)
  81             || IsEqualGUID(guid, &GUID_Damper)
  82             || IsEqualGUID(guid, &GUID_Inertia)
  83             || IsEqualGUID(guid, &GUID_Friction)) {
  84         return DIEFT_CONDITION;
  85     } else if (IsEqualGUID(guid, &GUID_CustomForce)) {
  86         return DIEFT_CUSTOMFORCE;
  87     } else {
  88         WARN("GUID (%s) is not a known force type\n", _dump_dinput_GUID(guid));
  89         return 0;
  90     }
  91 }
  92
  93
  94 /******************************************************************************
  95  *      DirectInputEffect debug helpers
  96  */
  97
  98 static void _dump_DIEFFECT_flags(DWORD dwFlags)
  99 {
 100     if (TRACE_ON(dinput)) {
 101         unsigned int   i;
 102         static const struct {
 103             DWORD       mask;
 104             const char  *name;
 105         } flags[] = {
 106 #define FE(x) { x, #x}
 107             FE(DIEFF_CARTESIAN),
 108             FE(DIEFF_OBJECTIDS),
 109             FE(DIEFF_OBJECTOFFSETS),
 110             FE(DIEFF_POLAR),
 111             FE(DIEFF_SPHERICAL)
 112 #undef FE
 113         };
 114         for (i = 0; i < (sizeof(flags) / sizeof(flags[0])); i++)
 115             if (flags[i].mask & dwFlags)
 116                 TRACE("%s ", flags[i].name);
 117         TRACE("\n");
 118     }
 119 }
 120
 121 static void _dump_DIENVELOPE(LPCDIENVELOPE env)
 122 {
 123     if (env->dwSize != sizeof(DIENVELOPE)) {
 124         WARN("Non-standard DIENVELOPE structure size %d.\n", env->dwSize);
 125     }
 126     TRACE("Envelope has attack (level: %d time: %d), fade (level: %d time: %d)\n",
 127           env->dwAttackLevel, env->dwAttackTime, env->dwFadeLevel, env->dwFadeTime);
 128 }
 129
 130 static void _dump_DICONSTANTFORCE(LPCDICONSTANTFORCE frc)
 131 {
 132     TRACE("Constant force has magnitude %d\n", frc->lMagnitude);
 133 }
 134
 135 static void _dump_DIPERIODIC(LPCDIPERIODIC frc)
 136 {
 137     TRACE("Periodic force has magnitude %d, offset %d, phase %d, period %d\n",
 138           frc->dwMagnitude, frc->lOffset, frc->dwPhase, frc->dwPeriod);
 139 }
 140
 141 static void _dump_DIRAMPFORCE(LPCDIRAMPFORCE frc)
 142 {
 143     TRACE("Ramp force has start %d, end %d\n",
 144           frc->lStart, frc->lEnd);
 145 }
 146
 147 static void _dump_DICONDITION(LPCDICONDITION frc)
 148 {
 149     TRACE("Condition has offset %d, pos/neg coefficients %d and %d, pos/neg saturations %d and %d, deadband %d\n",
 150           frc->lOffset, frc->lPositiveCoefficient, frc->lNegativeCoefficient,
 151           frc->dwPositiveSaturation, frc->dwNegativeSaturation, frc->lDeadBand);
 152 }
 153
 154 static void _dump_DICUSTOMFORCE(LPCDICUSTOMFORCE frc)
 155 {
 156     unsigned int i;
 157     TRACE("Custom force uses %d channels, sample period %d.  Has %d samples at %p.\n",
 158           frc->cChannels, frc->dwSamplePeriod, frc->cSamples, frc->rglForceData);
 159     if (frc->cSamples % frc->cChannels != 0)
 160         WARN("Custom force has a non-integral samples-per-channel count!\n");
 161     if (TRACE_ON(dinput)) {
 162         TRACE("Custom force data (time aligned, axes in order):\n");
 163         for (i = 1; i <= frc->cSamples; ++i) {
 164             TRACE("%d ", frc->rglForceData[i]);
 165             if (i % frc->cChannels == 0)
 166                 TRACE("\n");
 167         }
 168     }
 169 }
 170
 171 static void _dump_DIEFFECT(LPCDIEFFECT eff, REFGUID guid)
 172 {
 173     unsigned int i;
 174     DWORD type = _typeFromGUID(guid);
 175
 176     TRACE("Dumping DIEFFECT structure:\n");
 177     TRACE("  - dwSize: %d\n", eff->dwSize);
 178     if ((eff->dwSize != sizeof(DIEFFECT)) && (eff->dwSize != sizeof(DIEFFECT_DX5))) {
 179         WARN("Non-standard DIEFFECT structure size %d\n", eff->dwSize);
 180     }
 181     TRACE("  - dwFlags: %d\n", eff->dwFlags);
 182     TRACE("    ");
 183     _dump_DIEFFECT_flags(eff->dwFlags);
 184     TRACE("  - dwDuration: %d\n", eff->dwDuration);
 185     TRACE("  - dwGain: %d\n", eff->dwGain);
 186     if (eff->dwGain > 10000)
 187         WARN("dwGain is out of range (>10,000)\n");
 188     TRACE("  - dwTriggerButton: %d\n", eff->dwTriggerButton);
 189     TRACE("  - dwTriggerRepeatInterval: %d\n", eff->dwTriggerRepeatInterval);
 190     TRACE("  - cAxes: %d\n", eff->cAxes);
 191     TRACE("  - rgdwAxes: %p\n", eff->rgdwAxes);
 192     if (TRACE_ON(dinput) && eff->rgdwAxes) {
 193         TRACE("    ");
 194         for (i = 0; i < eff->cAxes; ++i)
 195             TRACE("%d ", eff->rgdwAxes[i]);
 196         TRACE("\n");
 197     }
 198     TRACE("  - rglDirection: %p\n", eff->rglDirection);
 199     TRACE("  - lpEnvelope: %p\n", eff->lpEnvelope);
 200     TRACE("  - cbTypeSpecificParams: %d\n", eff->cbTypeSpecificParams);
 201     TRACE("  - lpvTypeSpecificParams: %p\n", eff->lpvTypeSpecificParams);
 202     if (eff->dwSize > sizeof(DIEFFECT_DX5))
 203         TRACE("  - dwStartDelay: %d\n", eff->dwStartDelay);
 204     if (eff->lpEnvelope != NULL)
 205         _dump_DIENVELOPE(eff->lpEnvelope);
 206     if (type == DIEFT_CONSTANTFORCE) {
 207         if (eff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE)) {
 208             WARN("Effect claims to be a constant force but the type-specific params are the wrong size!\n");
 209         } else {
 210             _dump_DICONSTANTFORCE(eff->lpvTypeSpecificParams);
 211         }
 212     } else if (type == DIEFT_PERIODIC) {
 213         if (eff->cbTypeSpecificParams != sizeof(DIPERIODIC)) {
 214             WARN("Effect claims to be a periodic force but the type-specific params are the wrong size!\n");
 215         } else {
 216             _dump_DIPERIODIC(eff->lpvTypeSpecificParams);
 217         }
 218     } else if (type == DIEFT_RAMPFORCE) {
 219         if (eff->cbTypeSpecificParams != sizeof(DIRAMPFORCE)) {
 220             WARN("Effect claims to be a ramp force but the type-specific params are the wrong size!\n");
 221         } else {
 222             _dump_DIRAMPFORCE(eff->lpvTypeSpecificParams);
 223         }
 224     } else if (type == DIEFT_CONDITION) {
 225         if (eff->cbTypeSpecificParams != sizeof(DICONDITION)) {
 226             WARN("Effect claims to be a condition but the type-specific params are the wrong size!\n");
 227         } else {
 228             _dump_DICONDITION(eff->lpvTypeSpecificParams);
 229         }
 230     } else if (type == DIEFT_CUSTOMFORCE) {
 231         if (eff->cbTypeSpecificParams != sizeof(DICUSTOMFORCE)) {
 232             WARN("Effect claims to be a custom force but the type-specific params are the wrong size!\n");
 233         } else {
 234             _dump_DICUSTOMFORCE(eff->lpvTypeSpecificParams);
 235         }
 236     }
 237 }
 238
 239
 240 /******************************************************************************
 241  *      LinuxInputEffectImpl
 242  */
 243
 244 static ULONG WINAPI LinuxInputEffectImpl_AddRef(
 245         LPDIRECTINPUTEFFECT iface)
 246 {
 247     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 248     return InterlockedIncrement(&(This->ref));
 249 }
 250
 251 static HRESULT WINAPI LinuxInputEffectImpl_Download(
 252         LPDIRECTINPUTEFFECT iface)
 253 {
 254     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 255
 256     TRACE("(this=%p)\n", This);
 257
 258     if (ioctl(*(This->fd), EVIOCSFF, &This->effect) == -1) {
 259         if (errno == ENOMEM) {
 260             return DIERR_DEVICEFULL;
 261         } else {
 262             FIXME("Could not upload effect. Assuming a disconnected device %d \"%s\".\n", *This->fd, strerror(errno));
 263             return DIERR_INPUTLOST;
 264         }
 265     }
 266
 267     return DI_OK;
 268 }
 269
 270 static HRESULT WINAPI LinuxInputEffectImpl_Escape(
 271         LPDIRECTINPUTEFFECT iface,
 272         LPDIEFFESCAPE pesc)
 273 {
 274     WARN("(this=%p,%p): invalid: no hardware-specific escape codes in this"
 275          " driver!\n", iface, pesc);
 276
 277     return DI_OK;
 278 }
 279
 280 static HRESULT WINAPI LinuxInputEffectImpl_GetEffectGuid(
 281         LPDIRECTINPUTEFFECT iface,
 282         LPGUID pguid)
 283 {
 284     LinuxInputEffectImpl *This = (LinuxInputEffectImpl*)iface;
 285
 286     TRACE("(this=%p,%p)\n", This, pguid);
 287
 288     pguid = &This->guid;
 289
 290     return DI_OK;
 291 }
 292
 293 static HRESULT WINAPI LinuxInputEffectImpl_GetEffectStatus(
 294         LPDIRECTINPUTEFFECT iface,
 295         LPDWORD pdwFlags)
 296 {
 297     TRACE("(this=%p,%p)\n", iface, pdwFlags);
 298
 299     /* linux sends the effect status through an event.
 300      * that event is trapped by our parent joystick driver
 301      * and there is no clean way to pass it back to us. */
 302     FIXME("Not enough information to provide a status.\n");
 303
 304     (*pdwFlags) = 0;
 305
 306     return DI_OK;
 307 }
 308
 309 static HRESULT WINAPI LinuxInputEffectImpl_GetParameters(
 310         LPDIRECTINPUTEFFECT iface,
 311         LPDIEFFECT peff,
 312         DWORD dwFlags)
 313 {
 314     HRESULT diErr = DI_OK;
 315     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 316     TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
 317
 318     /* Major conversion factors are:
 319      * times: millisecond (linux) -> microsecond (windows) (x * 1000)
 320      * forces: scale 0x7FFF (linux) -> scale 10000 (windows) approx ((x / 33) * 10)
 321      * angles: scale 0x7FFF (linux) -> scale 35999 (windows) approx ((x / 33) * 36)
 322      * angle bases: 0 -> -y (down) (linux) -> 0 -> +x (right) (windows)
 323      */
 324
 325     if (dwFlags & DIEP_AXES) {
 326         if (peff->cAxes < 2 /* linuxinput effects always use 2 axes, x and y */)
 327             diErr = DIERR_MOREDATA;
 328         peff->cAxes = 2;
 329         if (diErr)
 330             return diErr;
 331         else {
 332             peff->rgdwAxes[0] = DIJOFS_X;
 333             peff->rgdwAxes[1] = DIJOFS_Y;
 334         }
 335     }
 336
 337     if (dwFlags & DIEP_DIRECTION) {
 338         if (peff->cAxes < 2)
 339             diErr = DIERR_MOREDATA;
 340         peff->cAxes = 2;
 341         if (diErr)
 342             return diErr;
 343         else {
 344             if (peff->dwFlags & DIEFF_CARTESIAN) {
 345                 peff->rglDirection[0] = (long)(sin(M_PI * 3 * This->effect.direction / 0x7FFF) * 1000);
 346                 peff->rglDirection[1] = (long)(cos(M_PI * 3 * This->effect.direction / 0x7FFF) * 1000);
 347             } else {
 348                 /* Polar and spherical coordinates are the same for two or less
 349                  * axes.
 350                  * Note that we also use this case if NO flags are marked.
 351                  * According to MSDN, we should return the direction in the
 352                  * format that it was specified in, if no flags are marked.
 353                  */
 354                 peff->rglDirection[0] = (This->effect.direction / 33) * 36 + 9000;
 355                 if (peff->rglDirection[0] > 35999)
 356                     peff->rglDirection[0] -= 35999;
 357             }
 358         }
 359     }
 360
 361     if (dwFlags & DIEP_DURATION) {
 362         peff->dwDuration = (DWORD)This->effect.replay.length * 1000;
 363     }
 364
 365     if (dwFlags & DIEP_ENVELOPE) {
 366         struct ff_envelope* env;
 367         if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope;
 368         else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope;
 369         else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope;
 370         else env = NULL;
 371         if (env == NULL) {
 372             peff->lpEnvelope = NULL;
 373         } else if (peff->lpEnvelope == NULL) {
 374             return DIERR_INVALIDPARAM;
 375         } else {
 376             peff->lpEnvelope->dwAttackLevel = (env->attack_level / 33) * 10;
 377             peff->lpEnvelope->dwAttackTime = env->attack_length * 1000;
 378             peff->lpEnvelope->dwFadeLevel = (env->fade_level / 33) * 10;
 379             peff->lpEnvelope->dwFadeTime = env->fade_length * 1000;
 380         }
 381     }
 382
 383     if (dwFlags & DIEP_GAIN) {
 384         peff->dwGain = This->gain * 10000 / 0xFFFF;
 385     }
 386
 387     if (dwFlags & DIEP_SAMPLEPERIOD) {
 388         /* the linux input ff driver has no support for setting
 389          * the playback sample period.  0 means default. */
 390         peff->dwSamplePeriod = 0;
 391     }
 392
 393     if (dwFlags & DIEP_STARTDELAY) {
 394         peff->dwStartDelay = This->effect.replay.delay * 1000;
 395     }
 396
 397     if (dwFlags & DIEP_TRIGGERBUTTON) {
 398         FIXME("LinuxInput button mapping needs redoing; for now, assuming we're using an actual joystick.\n");
 399         peff->dwTriggerButton = DIJOFS_BUTTON(This->effect.trigger.button - BTN_JOYSTICK);
 400     }
 401
 402     if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) {
 403         peff->dwTriggerRepeatInterval = This->effect.trigger.interval * 1000;
 404     }
 405
 406     if (dwFlags & DIEP_TYPESPECIFICPARAMS) {
 407         DWORD expectedsize = 0;
 408         if (This->effect.type == FF_PERIODIC) {
 409             expectedsize = sizeof(DIPERIODIC);
 410         } else if (This->effect.type == FF_CONSTANT) {
 411             expectedsize = sizeof(DICONSTANTFORCE);
 412         } else if (This->effect.type == FF_SPRING
 413                 || This->effect.type == FF_FRICTION
 414                 || This->effect.type == FF_INERTIA
 415                 || This->effect.type == FF_DAMPER) {
 416             expectedsize = sizeof(DICONDITION) * 2;
 417         } else if (This->effect.type == FF_RAMP) {
 418             expectedsize = sizeof(DIRAMPFORCE);
 419         }
 420         if (expectedsize > peff->cbTypeSpecificParams)
 421             diErr = DIERR_MOREDATA;
 422         peff->cbTypeSpecificParams = expectedsize;
 423         if (diErr)
 424             return diErr;
 425         else {
 426             if (This->effect.type == FF_PERIODIC) {
 427                 LPDIPERIODIC tsp = peff->lpvTypeSpecificParams;
 428                 tsp->dwMagnitude = (This->effect.u.periodic.magnitude / 33) * 10;
 429                 tsp->lOffset = (This->effect.u.periodic.offset / 33) * 10;
 430                 tsp->dwPhase = (This->effect.u.periodic.phase / 33) * 36;
 431                 tsp->dwPeriod = (This->effect.u.periodic.period * 1000);
 432             } else if (This->effect.type == FF_CONSTANT) {
 433                 LPDICONSTANTFORCE tsp = peff->lpvTypeSpecificParams;
 434                 tsp->lMagnitude = (This->effect.u.constant.level / 33) * 10;
 435             } else if (This->effect.type == FF_SPRING
 436                     || This->effect.type == FF_FRICTION
 437                     || This->effect.type == FF_INERTIA
 438                     || This->effect.type == FF_DAMPER) {
 439                 LPDICONDITION tsp = peff->lpvTypeSpecificParams;
 440                 int i;
 441                 for (i = 0; i < 2; ++i) {
 442                     tsp[i].lOffset = (This->effect.u.condition[i].center / 33) * 10;
 443                     tsp[i].lPositiveCoefficient = (This->effect.u.condition[i].right_coeff / 33) * 10;
 444                     tsp[i].lNegativeCoefficient = (This->effect.u.condition[i].left_coeff / 33) * 10;
 445                     tsp[i].dwPositiveSaturation = (This->effect.u.condition[i].right_saturation / 33) * 10;
 446                     tsp[i].dwNegativeSaturation = (This->effect.u.condition[i].left_saturation / 33) * 10;
 447                     tsp[i].lDeadBand = (This->effect.u.condition[i].deadband / 33) * 10;
 448                 }
 449             } else if (This->effect.type == FF_RAMP) {
 450                 LPDIRAMPFORCE tsp = peff->lpvTypeSpecificParams;
 451                 tsp->lStart = (This->effect.u.ramp.start_level / 33) * 10;
 452                 tsp->lEnd = (This->effect.u.ramp.end_level / 33) * 10;
 453             }
 454         }
 455     }
 456
 457     return diErr;
 458 }
 459
 460 static HRESULT WINAPI LinuxInputEffectImpl_Initialize(
 461         LPDIRECTINPUTEFFECT iface,
 462         HINSTANCE hinst,
 463         DWORD dwVersion,
 464         REFGUID rguid)
 465 {
 466     FIXME("(this=%p,%p,%d,%s): stub!\n",
 467          iface, hinst, dwVersion, debugstr_guid(rguid));
 468
 469     return DI_OK;
 470 }
 471
 472 static HRESULT WINAPI LinuxInputEffectImpl_QueryInterface(
 473         LPDIRECTINPUTEFFECT iface,
 474         REFIID riid,
 475         void **ppvObject)
 476 {
 477     LinuxInputEffectImpl* This = (LinuxInputEffectImpl*)iface;
 478
 479     TRACE("(this=%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject);
 480
 481     if (IsEqualGUID(&IID_IUnknown, riid) ||
 482         IsEqualGUID(&IID_IDirectInputEffect, riid)) {
 483             LinuxInputEffectImpl_AddRef(iface);
 484             *ppvObject = This;
 485             return 0;
 486     }
 487
 488     TRACE("Unsupported interface!\n");
 489     return E_FAIL;
 490 }
 491
 492 static HRESULT WINAPI LinuxInputEffectImpl_Start(
 493         LPDIRECTINPUTEFFECT iface,
 494         DWORD dwIterations,
 495         DWORD dwFlags)
 496 {
 497     struct input_event event;
 498     LinuxInputEffectImpl* This = (LinuxInputEffectImpl*)iface;
 499
 500     TRACE("(this=%p,%d,%d)\n", This, dwIterations, dwFlags);
 501
 502     if (!(dwFlags & DIES_NODOWNLOAD)) {
 503         /* Download the effect if necessary */
 504         if (This->effect.id == -1) {
 505             HRESULT res = LinuxInputEffectImpl_Download(iface);
 506             if (res != DI_OK)
 507                 return res;
 508         }
 509     }
 510
 511     if (dwFlags & DIES_SOLO) {
 512         FIXME("Solo mode requested: should be stopping all effects here!\n");
 513     }
 514
 515     event.type = EV_FF;
 516     event.code = This->effect.id;
 517     event.value = dwIterations;
 518     if (write(*(This->fd), &event, sizeof(event)) == -1) {
 519         FIXME("Unable to write event.  Assuming device disconnected.\n");
 520         return DIERR_INPUTLOST;
 521     }
 522
 523     return DI_OK;
 524 }
 525
 526 static HRESULT WINAPI LinuxInputEffectImpl_SetParameters(
 527         LPDIRECTINPUTEFFECT iface,
 528         LPCDIEFFECT peff,
 529         DWORD dwFlags)
 530 {
 531     LinuxInputEffectImpl* This = (LinuxInputEffectImpl*)iface;
 532     DWORD type = _typeFromGUID(&This->guid);
 533     HRESULT retval = DI_OK;
 534
 535     TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
 536
 537     _dump_DIEFFECT(peff, &This->guid);
 538
 539     if ((dwFlags & ~DIEP_NORESTART & ~DIEP_NODOWNLOAD & ~DIEP_START) == 0) {
 540         /* set everything */
 541         dwFlags = DIEP_AXES | DIEP_DIRECTION | DIEP_DURATION | DIEP_ENVELOPE |
 542             DIEP_GAIN | DIEP_SAMPLEPERIOD | DIEP_STARTDELAY | DIEP_TRIGGERBUTTON |
 543             DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS;
 544     }
 545
 546     if (dwFlags & DIEP_AXES) {
 547         /* the linux input effect system only supports one or two axes */
 548         if (peff->cAxes > 2)
 549             return DIERR_INVALIDPARAM;
 550         else if (peff->cAxes < 1)
 551             return DIERR_INCOMPLETEEFFECT;
 552         This->first_axis_is_x = peff->rgdwAxes[0] == DIJOFS_X;
 553     }
 554
 555     /* some of this may look funky, but it's 'cause the linux driver and directx have
 556      * different opinions about which way direction "0" is.  directx has 0 along the x
 557      * axis (left), linux has it along the y axis (down). */
 558     if (dwFlags & DIEP_DIRECTION) {
 559         if (peff->cAxes == 1) {
 560             if (peff->dwFlags & DIEFF_CARTESIAN) {
 561                 if (dwFlags & DIEP_AXES) {
 562                     if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] >= 0)
 563                         This->effect.direction = 0x4000;
 564                     else if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] < 0)
 565                         This->effect.direction = 0xC000;
 566                     else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] >= 0)
 567                         This->effect.direction = 0;
 568                     else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] < 0)
 569                         This->effect.direction = 0x8000;
 570                 }
 571             } else {
 572                 /* one-axis effects must use cartesian coords */
 573                 return DIERR_INVALIDPARAM;
 574             }
 575         } else { /* two axes */
 576             if (peff->dwFlags & DIEFF_CARTESIAN) {
 577                 LONG x, y;
 578                 if (This->first_axis_is_x) {
 579                     x = peff->rglDirection[0];
 580                     y = peff->rglDirection[1];
 581                 } else {
 582                     x = peff->rglDirection[1];
 583                     y = peff->rglDirection[0];
 584                 }
 585                 This->effect.direction = (int)((3 * M_PI / 2 - atan2(y, x)) * -0x7FFF / M_PI);
 586             } else {
 587                 /* Polar and spherical are the same for 2 axes */
 588                 /* Precision is important here, so we do double math with exact constants */
 589                 This->effect.direction = (int)(((double)peff->rglDirection[0] - 90) / 35999) * 0x7FFF;
 590             }
 591         }
 592     }
 593
 594     if (dwFlags & DIEP_DURATION)
 595         This->effect.replay.length = peff->dwDuration / 1000;
 596
 597     if (dwFlags & DIEP_ENVELOPE) {
 598         struct ff_envelope* env;
 599         if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope;
 600         else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope;
 601         else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope;
 602         else env = NULL;
 603
 604         if (peff->lpEnvelope == NULL) {
 605             /* if this type had an envelope, reset it
 606              * note that length can never be zero, so we set it to something minuscule */
 607             if (env) {
 608                 env->attack_length = 0x10;
 609                 env->attack_level = 0x7FFF;
 610                 env->fade_length = 0x10;
 611                 env->fade_level = 0x7FFF;
 612             }
 613         } else {
 614             /* did we get passed an envelope for a type that doesn't even have one? */
 615             if (!env) return DIERR_INVALIDPARAM;
 616             /* copy the envelope */
 617             env->attack_length = peff->lpEnvelope->dwAttackTime / 1000;
 618             env->attack_level = (peff->lpEnvelope->dwAttackLevel / 10) * 32;
 619             env->fade_length = peff->lpEnvelope->dwFadeTime / 1000;
 620             env->fade_level = (peff->lpEnvelope->dwFadeLevel / 10) * 32;
 621         }
 622     }
 623
 624     /* Gain and Sample Period settings are not supported by the linux
 625      * event system */
 626     if (dwFlags & DIEP_GAIN) {
 627         This->gain = 0xFFFF * peff->dwGain / 10000;
 628         TRACE("Effect gain requested but no effect gain functionality present.\n");
 629     }
 630
 631     if (dwFlags & DIEP_SAMPLEPERIOD)
 632         TRACE("Sample period requested but no sample period functionality present.\n");
 633
 634     if (dwFlags & DIEP_STARTDELAY)
 635         This->effect.replay.delay = peff->dwStartDelay / 1000;
 636
 637     if (dwFlags & DIEP_TRIGGERBUTTON) {
 638         if (peff->dwTriggerButton != -1) {
 639             FIXME("Linuxinput button mapping needs redoing, assuming we're using a joystick.\n");
 640             FIXME("Trigger button translation not yet implemented!\n");
 641         }
 642         This->effect.trigger.button = 0;
 643     }
 644
 645     if (dwFlags & DIEP_TRIGGERREPEATINTERVAL)
 646         This->effect.trigger.interval = peff->dwTriggerRepeatInterval / 1000;
 647
 648     if (dwFlags & DIEP_TYPESPECIFICPARAMS) {
 649         if (!(peff->lpvTypeSpecificParams))
 650             return DIERR_INCOMPLETEEFFECT;
 651         if (type == DIEFT_PERIODIC) {
 652             LPCDIPERIODIC tsp;
 653             if (peff->cbTypeSpecificParams != sizeof(DIPERIODIC))
 654                 return DIERR_INVALIDPARAM;
 655             tsp = peff->lpvTypeSpecificParams;
 656             This->effect.u.periodic.magnitude = (tsp->dwMagnitude / 10) * 32;
 657             This->effect.u.periodic.offset = (tsp->lOffset / 10) * 32;
 658             This->effect.u.periodic.phase = (tsp->dwPhase / 9) * 8; /* == (/ 36 * 32) */
 659             This->effect.u.periodic.period = tsp->dwPeriod / 1000;
 660         } else if (type == DIEFT_CONSTANTFORCE) {
 661             LPCDICONSTANTFORCE tsp;
 662             if (peff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE))
 663                 return DIERR_INVALIDPARAM;
 664             tsp = peff->lpvTypeSpecificParams;
 665             This->effect.u.constant.level = (max(min(tsp->lMagnitude, 10000), -10000) / 10) * 32;
 666         } else if (type == DIEFT_RAMPFORCE) {
 667             LPCDIRAMPFORCE tsp;
 668             if (peff->cbTypeSpecificParams != sizeof(DIRAMPFORCE))
 669                 return DIERR_INVALIDPARAM;
 670             tsp = peff->lpvTypeSpecificParams;
 671             This->effect.u.ramp.start_level = (tsp->lStart / 10) * 32;
 672             This->effect.u.ramp.end_level = (tsp->lStart / 10) * 32;
 673         } else if (type == DIEFT_CONDITION) {
 674             LPCDICONDITION tsp = peff->lpvTypeSpecificParams;
 675             if (peff->cbTypeSpecificParams == sizeof(DICONDITION)) {
 676                 /* One condition block.  This needs to be rotated to direction,
 677                  * and expanded to separate x and y conditions. */
 678                 int i;
 679                 double factor[2];
 680                 factor[0] = asin((This->effect.direction * 3.0 * M_PI) / 0x7FFF);
 681                 factor[1] = acos((This->effect.direction * 3.0 * M_PI) / 0x7FFF);
 682                 for (i = 0; i < 2; ++i) {
 683                     This->effect.u.condition[i].center = (int)(factor[i] * (tsp->lOffset / 10) * 32);
 684                     This->effect.u.condition[i].right_coeff = (int)(factor[i] * (tsp->lPositiveCoefficient / 10) * 32);
 685                     This->effect.u.condition[i].left_coeff = (int)(factor[i] * (tsp->lNegativeCoefficient / 10) * 32);
 686                     This->effect.u.condition[i].right_saturation = (int)(factor[i] * (tsp->dwPositiveSaturation / 10) * 32);
 687                     This->effect.u.condition[i].left_saturation = (int)(factor[i] * (tsp->dwNegativeSaturation / 10) * 32);
 688                     This->effect.u.condition[i].deadband = (int)(factor[i] * (tsp->lDeadBand / 10) * 32);
 689                 }
 690             } else if (peff->cbTypeSpecificParams == 2 * sizeof(DICONDITION)) {
 691                 /* Two condition blocks.  Direct parameter copy. */
 692                 int i;
 693                 for (i = 0; i < 2; ++i) {
 694                     This->effect.u.condition[i].center = (tsp[i].lOffset / 10) * 32;
 695                     This->effect.u.condition[i].right_coeff = (tsp[i].lPositiveCoefficient / 10) * 32;
 696                     This->effect.u.condition[i].left_coeff = (tsp[i].lNegativeCoefficient / 10) * 32;
 697                     This->effect.u.condition[i].right_saturation = (tsp[i].dwPositiveSaturation / 10) * 32;
 698                     This->effect.u.condition[i].left_saturation = (tsp[i].dwNegativeSaturation / 10) * 32;
 699                     This->effect.u.condition[i].deadband = (tsp[i].lDeadBand / 10) * 32;
 700                 }
 701             } else {
 702                 return DIERR_INVALIDPARAM;
 703             }
 704         } else {
 705             FIXME("Custom force types are not supported\n");
 706             return DIERR_INVALIDPARAM;
 707         }
 708     }
 709
 710     if (!(dwFlags & DIEP_NODOWNLOAD))
 711         retval = LinuxInputEffectImpl_Download(iface);
 712     if (retval != DI_OK)
 713         return DI_DOWNLOADSKIPPED;
 714
 715     if (dwFlags & DIEP_NORESTART)
 716         TRACE("DIEP_NORESTART: not handled (we have no control of that).\n");
 717
 718     if (dwFlags & DIEP_START)
 719         retval = LinuxInputEffectImpl_Start(iface, 1, 0);
 720     if (retval != DI_OK)
 721         return retval;
 722
 723     return DI_OK;
 724 }
 725
 726 static HRESULT WINAPI LinuxInputEffectImpl_Stop(
 727         LPDIRECTINPUTEFFECT iface)
 728 {
 729     struct input_event event;
 730     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 731
 732     TRACE("(this=%p)\n", This);
 733
 734     event.type = EV_FF;
 735     event.code = This->effect.id;
 736     event.value = 0;
 737     /* we don't care about the success or failure of this call */
 738     write(*(This->fd), &event, sizeof(event));
 739
 740     return DI_OK;
 741 }
 742
 743 static HRESULT WINAPI LinuxInputEffectImpl_Unload(
 744         LPDIRECTINPUTEFFECT iface)
 745 {
 746     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 747     TRACE("(this=%p)\n", This);
 748
 749     /* Erase the downloaded effect */
 750     if (ioctl(*(This->fd), EVIOCRMFF, This->effect.id) == -1)
 751         return DIERR_INVALIDPARAM;
 752
 753     /* Mark the effect as deallocated */
 754     This->effect.id = -1;
 755
 756     return DI_OK;
 757 }
 758
 759 static ULONG WINAPI LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface)
 760 {
 761     LinuxInputEffectImpl *This = (LinuxInputEffectImpl *)iface;
 762     ULONG ref = InterlockedDecrement(&(This->ref));
 763
 764     if (ref == 0)
 765     {
 766         LinuxInputEffectImpl_Stop(iface);
 767         LinuxInputEffectImpl_Unload(iface);
 768         list_remove(This->entry);
 769         HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This->entry, effect_list_item, entry));
 770         HeapFree(GetProcessHeap(), 0, This);
 771     }
 772     return ref;
 773 }
 774
 775 /******************************************************************************
 776  *      LinuxInputEffect
 777  */
 778
 779 HRESULT linuxinput_create_effect(
 780         int* fd,
 781         REFGUID rguid,
 782         struct list *parent_list_entry,
 783         LPDIRECTINPUTEFFECT* peff)
 784 {
 785     LinuxInputEffectImpl* newEffect = HeapAlloc(GetProcessHeap(),
 786         HEAP_ZERO_MEMORY, sizeof(LinuxInputEffectImpl));
 787     DWORD type = _typeFromGUID(rguid);
 788
 789     newEffect->lpVtbl = &LinuxInputEffectVtbl;
 790     newEffect->ref = 1;
 791     newEffect->guid = *rguid;
 792     newEffect->fd = fd;
 793     newEffect->gain = 0xFFFF;
 794
 795     /* set the type.  this cannot be changed over the effect's life. */
 796     switch (type) {
 797         case DIEFT_PERIODIC:
 798             newEffect->effect.type = FF_PERIODIC;
 799             if (IsEqualGUID(rguid, &GUID_Sine)) {
 800                 newEffect->effect.u.periodic.waveform = FF_SINE;
 801             } else if (IsEqualGUID(rguid, &GUID_Triangle)) {
 802                 newEffect->effect.u.periodic.waveform = FF_TRIANGLE;
 803             } else if (IsEqualGUID(rguid, &GUID_Square)) {
 804                 newEffect->effect.u.periodic.waveform = FF_SQUARE;
 805             } else if (IsEqualGUID(rguid, &GUID_SawtoothUp)) {
 806                 newEffect->effect.u.periodic.waveform = FF_SAW_UP;
 807             } else if (IsEqualGUID(rguid, &GUID_SawtoothDown)) {
 808                 newEffect->effect.u.periodic.waveform = FF_SAW_DOWN;
 809             }
 810             break;
 811         case DIEFT_CONSTANTFORCE:
 812             newEffect->effect.type = FF_CONSTANT;
 813             break;
 814         case DIEFT_RAMPFORCE:
 815             newEffect->effect.type = FF_RAMP;
 816             break;
 817         case DIEFT_CONDITION:
 818             if (IsEqualGUID(rguid, &GUID_Spring)) {
 819                 newEffect->effect.type = FF_SPRING;
 820             } else if (IsEqualGUID(rguid, &GUID_Friction)) {
 821                 newEffect->effect.type = FF_FRICTION;
 822             } else if (IsEqualGUID(rguid, &GUID_Inertia)) {
 823                 newEffect->effect.type = FF_INERTIA;
 824             } else if (IsEqualGUID(rguid, &GUID_Damper)) {
 825                 newEffect->effect.type = FF_DAMPER;
 826             }
 827             break;
 828         case DIEFT_CUSTOMFORCE:
 829             FIXME("Custom forces are not supported.\n");
 830             HeapFree(GetProcessHeap(), 0, newEffect);
 831             return DIERR_INVALIDPARAM;
 832         default:
 833             FIXME("Unknown force type 0x%x.\n", type);
 834             HeapFree(GetProcessHeap(), 0, newEffect);
 835             return DIERR_INVALIDPARAM;
 836     }
 837
 838     /* mark as non-uploaded */
 839     newEffect->effect.id = -1;
 840
 841     newEffect->entry = parent_list_entry;
 842
 843     *peff = (LPDIRECTINPUTEFFECT)newEffect;
 844
 845     TRACE("Creating linux input system effect (%p) with guid %s\n",
 846           *peff, _dump_dinput_GUID(rguid));
 847
 848     return DI_OK;
 849 }
 850
 851 HRESULT linuxinput_get_info_A(
 852         int fd,
 853         REFGUID rguid,
 854         LPDIEFFECTINFOA info)
 855 {
 856     DWORD type = _typeFromGUID(rguid);
 857
 858     TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
 859
 860     if (!info) return E_POINTER;
 861
 862     if (info->dwSize != sizeof(DIEFFECTINFOA)) return DIERR_INVALIDPARAM;
 863
 864     info->guid = *rguid;
 865
 866     info->dwEffType = type;
 867     /* the event device API does not support querying for all these things
 868      * therefore we assume that we have support for them
 869      * that's not as dangerous as it sounds, since drivers are allowed to
 870      * ignore parameters they claim to support anyway */
 871     info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE
 872                     | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION
 873                     | DIEFT_SATURATION | DIEFT_STARTDELAY;
 874
 875     /* again, assume we have support for everything */
 876     info->dwStaticParams = DIEP_ALLPARAMS;
 877     info->dwDynamicParams = info->dwStaticParams;
 878
 879     /* yes, this is windows behavior (print the GUID_Name for name) */
 880     strcpy(info->tszName, _dump_dinput_GUID(rguid));
 881
 882     return DI_OK;
 883 }
 884
 885 HRESULT linuxinput_get_info_W(
 886         int fd,
 887         REFGUID rguid,
 888         LPDIEFFECTINFOW info)
 889 {
 890     DWORD type = _typeFromGUID(rguid);
 891
 892     TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
 893
 894     if (!info) return E_POINTER;
 895
 896     if (info->dwSize != sizeof(DIEFFECTINFOW)) return DIERR_INVALIDPARAM;
 897
 898     info->guid = *rguid;
 899
 900     info->dwEffType = type;
 901     /* the event device API does not support querying for all these things
 902      * therefore we assume that we have support for them
 903      * that's not as dangerous as it sounds, since drivers are allowed to
 904      * ignore parameters they claim to support anyway */
 905     info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE
 906                     | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION
 907                     | DIEFT_SATURATION | DIEFT_STARTDELAY;
 908
 909     /* again, assume we have support for everything */
 910     info->dwStaticParams = DIEP_ALLPARAMS;
 911     info->dwDynamicParams = info->dwStaticParams;
 912
 913     /* yes, this is windows behavior (print the GUID_Name for name) */
 914     MultiByteToWideChar(CP_ACP, 0, _dump_dinput_GUID(rguid), -1,
 915                         info->tszName, MAX_PATH);
 916
 917     return DI_OK;
 918 }
 919
 920 static const IDirectInputEffectVtbl LinuxInputEffectVtbl = {
 921     LinuxInputEffectImpl_QueryInterface,
 922     LinuxInputEffectImpl_AddRef,
 923     LinuxInputEffectImpl_Release,
 924     LinuxInputEffectImpl_Initialize,
 925     LinuxInputEffectImpl_GetEffectGuid,
 926     LinuxInputEffectImpl_GetParameters,
 927     LinuxInputEffectImpl_SetParameters,
 928     LinuxInputEffectImpl_Start,
 929     LinuxInputEffectImpl_Stop,
 930     LinuxInputEffectImpl_GetEffectStatus,
 931     LinuxInputEffectImpl_Download,
 932     LinuxInputEffectImpl_Unload,
 933     LinuxInputEffectImpl_Escape
 934 };
 935
 936 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */