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