1 /* DirectInput Linux Event Device Effect
3 * Copyright 2005 Daniel Remenak
5 * Thanks to Google's Summer of Code Program (2005)
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.
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.
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
24 #ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
28 #ifdef HAVE_LINUX_INPUT_H
29 # include <linux/input.h>
37 #include "wine/debug.h"
38 #include "wine/unicode.h"
44 #include "device_private.h"
46 WINE_DEFAULT_DEBUG_CHANNEL(dinput
);
48 static const IDirectInputEffectVtbl LinuxInputEffectVtbl
;
49 typedef struct LinuxInputEffectImpl LinuxInputEffectImpl
;
50 struct LinuxInputEffectImpl
56 struct ff_effect effect
; /* Effect data */
57 int gain
; /* Effect gain */
58 int* fd
; /* Parent device */
59 struct list
*entry
; /* Entry into the parent's list of effects */
63 /******************************************************************************
64 * DirectInputEffect Functional Helper
67 static DWORD
_typeFromGUID(REFGUID guid
)
69 if (IsEqualGUID(guid
, &GUID_ConstantForce
)) {
70 return DIEFT_CONSTANTFORCE
;
71 } else if (IsEqualGUID(guid
, &GUID_Square
)
72 || IsEqualGUID(guid
, &GUID_Sine
)
73 || IsEqualGUID(guid
, &GUID_Triangle
)
74 || IsEqualGUID(guid
, &GUID_SawtoothUp
)
75 || IsEqualGUID(guid
, &GUID_SawtoothDown
)) {
76 return DIEFT_PERIODIC
;
77 } else if (IsEqualGUID(guid
, &GUID_RampForce
)) {
78 return DIEFT_RAMPFORCE
;
79 } else if (IsEqualGUID(guid
, &GUID_Spring
)
80 || IsEqualGUID(guid
, &GUID_Damper
)
81 || IsEqualGUID(guid
, &GUID_Inertia
)
82 || IsEqualGUID(guid
, &GUID_Friction
)) {
83 return DIEFT_CONDITION
;
84 } else if (IsEqualGUID(guid
, &GUID_CustomForce
)) {
85 return DIEFT_CUSTOMFORCE
;
87 WARN("GUID (%s) is not a known force type\n", _dump_dinput_GUID(guid
));
93 /******************************************************************************
94 * DirectInputEffect debug helpers
97 static void _dump_DIEFFECT_flags(DWORD dwFlags
)
99 if (TRACE_ON(dinput
)) {
101 static const struct {
105 #define FE(x) { x, #x}
108 FE(DIEFF_OBJECTOFFSETS
),
113 for (i
= 0; i
< (sizeof(flags
) / sizeof(flags
[0])); i
++)
114 if (flags
[i
].mask
& dwFlags
)
115 TRACE("%s ", flags
[i
].name
);
120 static void _dump_DIENVELOPE(LPCDIENVELOPE env
)
122 if (env
->dwSize
!= sizeof(DIENVELOPE
)) {
123 WARN("Non-standard DIENVELOPE structure size %d.\n", env
->dwSize
);
125 TRACE("Envelope has attack (level: %d time: %d), fade (level: %d time: %d)\n",
126 env
->dwAttackLevel
, env
->dwAttackTime
, env
->dwFadeLevel
, env
->dwFadeTime
);
129 static void _dump_DICONSTANTFORCE(LPCDICONSTANTFORCE frc
)
131 TRACE("Constant force has magnitude %d\n", frc
->lMagnitude
);
134 static void _dump_DIPERIODIC(LPCDIPERIODIC frc
)
136 TRACE("Periodic force has magnitude %d, offset %d, phase %d, period %d\n",
137 frc
->dwMagnitude
, frc
->lOffset
, frc
->dwPhase
, frc
->dwPeriod
);
140 static void _dump_DIRAMPFORCE(LPCDIRAMPFORCE frc
)
142 TRACE("Ramp force has start %d, end %d\n",
143 frc
->lStart
, frc
->lEnd
);
146 static void _dump_DICONDITION(LPCDICONDITION frc
)
148 TRACE("Condition has offset %d, pos/neg coefficients %d and %d, pos/neg saturations %d and %d, deadband %d\n",
149 frc
->lOffset
, frc
->lPositiveCoefficient
, frc
->lNegativeCoefficient
,
150 frc
->dwPositiveSaturation
, frc
->dwNegativeSaturation
, frc
->lDeadBand
);
153 static void _dump_DICUSTOMFORCE(LPCDICUSTOMFORCE frc
)
156 TRACE("Custom force uses %d channels, sample period %d. Has %d samples at %p.\n",
157 frc
->cChannels
, frc
->dwSamplePeriod
, frc
->cSamples
, frc
->rglForceData
);
158 if (frc
->cSamples
% frc
->cChannels
!= 0)
159 WARN("Custom force has a non-integral samples-per-channel count!\n");
160 if (TRACE_ON(dinput
)) {
161 TRACE("Custom force data (time aligned, axes in order):\n");
162 for (i
= 1; i
<= frc
->cSamples
; ++i
) {
163 TRACE("%d ", frc
->rglForceData
[i
]);
164 if (i
% frc
->cChannels
== 0)
170 static void _dump_DIEFFECT(LPCDIEFFECT eff
, REFGUID guid
)
173 DWORD type
= _typeFromGUID(guid
);
175 TRACE("Dumping DIEFFECT structure:\n");
176 TRACE(" - dwSize: %d\n", eff
->dwSize
);
177 if ((eff
->dwSize
!= sizeof(DIEFFECT
)) && (eff
->dwSize
!= sizeof(DIEFFECT_DX5
))) {
178 WARN("Non-standard DIEFFECT structure size %d\n", eff
->dwSize
);
180 TRACE(" - dwFlags: %d\n", eff
->dwFlags
);
182 _dump_DIEFFECT_flags(eff
->dwFlags
);
183 TRACE(" - dwDuration: %d\n", eff
->dwDuration
);
184 TRACE(" - dwGain: %d\n", eff
->dwGain
);
185 if (eff
->dwGain
> 10000)
186 WARN("dwGain is out of range (>10,000)\n");
187 TRACE(" - dwTriggerButton: %d\n", eff
->dwTriggerButton
);
188 TRACE(" - dwTriggerRepeatInterval: %d\n", eff
->dwTriggerRepeatInterval
);
189 TRACE(" - cAxes: %d\n", eff
->cAxes
);
190 TRACE(" - rgdwAxes: %p\n", eff
->rgdwAxes
);
191 if (TRACE_ON(dinput
) && eff
->rgdwAxes
) {
193 for (i
= 0; i
< eff
->cAxes
; ++i
)
194 TRACE("%d ", eff
->rgdwAxes
[i
]);
197 TRACE(" - rglDirection: %p\n", eff
->rglDirection
);
198 TRACE(" - lpEnvelope: %p\n", eff
->lpEnvelope
);
199 TRACE(" - cbTypeSpecificParams: %d\n", eff
->cbTypeSpecificParams
);
200 TRACE(" - lpvTypeSpecificParams: %p\n", eff
->lpvTypeSpecificParams
);
201 if (eff
->dwSize
> sizeof(DIEFFECT_DX5
))
202 TRACE(" - dwStartDelay: %d\n", eff
->dwStartDelay
);
203 if (eff
->lpEnvelope
!= NULL
)
204 _dump_DIENVELOPE(eff
->lpEnvelope
);
205 if (type
== DIEFT_CONSTANTFORCE
) {
206 if (eff
->cbTypeSpecificParams
!= sizeof(DICONSTANTFORCE
)) {
207 WARN("Effect claims to be a constant force but the type-specific params are the wrong size!\n");
209 _dump_DICONSTANTFORCE(eff
->lpvTypeSpecificParams
);
211 } else if (type
== DIEFT_PERIODIC
) {
212 if (eff
->cbTypeSpecificParams
!= sizeof(DIPERIODIC
)) {
213 WARN("Effect claims to be a periodic force but the type-specific params are the wrong size!\n");
215 _dump_DIPERIODIC(eff
->lpvTypeSpecificParams
);
217 } else if (type
== DIEFT_RAMPFORCE
) {
218 if (eff
->cbTypeSpecificParams
!= sizeof(DIRAMPFORCE
)) {
219 WARN("Effect claims to be a ramp force but the type-specific params are the wrong size!\n");
221 _dump_DIRAMPFORCE(eff
->lpvTypeSpecificParams
);
223 } else if (type
== DIEFT_CONDITION
) {
224 if (eff
->cbTypeSpecificParams
!= sizeof(DICONDITION
)) {
225 WARN("Effect claims to be a condition but the type-specific params are the wrong size!\n");
227 _dump_DICONDITION(eff
->lpvTypeSpecificParams
);
229 } else if (type
== DIEFT_CUSTOMFORCE
) {
230 if (eff
->cbTypeSpecificParams
!= sizeof(DICUSTOMFORCE
)) {
231 WARN("Effect claims to be a custom force but the type-specific params are the wrong size!\n");
233 _dump_DICUSTOMFORCE(eff
->lpvTypeSpecificParams
);
239 /******************************************************************************
240 * LinuxInputEffectImpl
243 static ULONG WINAPI
LinuxInputEffectImpl_AddRef(
244 LPDIRECTINPUTEFFECT iface
)
246 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
247 return InterlockedIncrement(&(This
->ref
));
250 static HRESULT WINAPI
LinuxInputEffectImpl_Download(
251 LPDIRECTINPUTEFFECT iface
)
253 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
255 TRACE("(this=%p)\n", This
);
257 if (ioctl(*(This
->fd
), EVIOCSFF
, &This
->effect
) == -1) {
258 if (errno
== ENOMEM
) {
259 return DIERR_DEVICEFULL
;
261 FIXME("Could not upload effect. Assuming a disconnected device %d \"%s\".\n", *This
->fd
, strerror(errno
));
262 return DIERR_INPUTLOST
;
269 static HRESULT WINAPI
LinuxInputEffectImpl_Escape(
270 LPDIRECTINPUTEFFECT iface
,
273 WARN("(this=%p,%p): invalid: no hardware-specific escape codes in this"
274 " driver!\n", iface
, pesc
);
279 static HRESULT WINAPI
LinuxInputEffectImpl_GetEffectGuid(
280 LPDIRECTINPUTEFFECT iface
,
283 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
285 TRACE("(this=%p,%p)\n", This
, pguid
);
292 static HRESULT WINAPI
LinuxInputEffectImpl_GetEffectStatus(
293 LPDIRECTINPUTEFFECT iface
,
296 TRACE("(this=%p,%p)\n", iface
, pdwFlags
);
298 /* linux sends the effect status through an event.
299 * that event is trapped by our parent joystick driver
300 * and there is no clean way to pass it back to us. */
301 FIXME("Not enough information to provide a status.\n");
308 static HRESULT WINAPI
LinuxInputEffectImpl_GetParameters(
309 LPDIRECTINPUTEFFECT iface
,
313 HRESULT diErr
= DI_OK
;
314 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
315 TRACE("(this=%p,%p,%d)\n", This
, peff
, dwFlags
);
317 /* Major conversion factors are:
318 * times: millisecond (linux) -> microsecond (windows) (x * 1000)
319 * forces: scale 0x7FFF (linux) -> scale 10000 (windows) approx ((x / 33) * 10)
320 * angles: scale 0x7FFF (linux) -> scale 35999 (windows) approx ((x / 33) * 36)
321 * angle bases: 0 -> -y (down) (linux) -> 0 -> +x (right) (windows)
324 if (dwFlags
& DIEP_AXES
) {
325 if (peff
->cAxes
< 2 /* linuxinput effects always use 2 axes, x and y */)
326 diErr
= DIERR_MOREDATA
;
331 peff
->rgdwAxes
[0] = DIJOFS_X
;
332 peff
->rgdwAxes
[1] = DIJOFS_Y
;
336 if (dwFlags
& DIEP_DIRECTION
) {
338 diErr
= DIERR_MOREDATA
;
343 if (peff
->dwFlags
& DIEFF_CARTESIAN
) {
344 peff
->rglDirection
[0] = (long)(sin(M_PI
* 3 * This
->effect
.direction
/ 0x7FFF) * 1000);
345 peff
->rglDirection
[1] = (long)(cos(M_PI
* 3 * This
->effect
.direction
/ 0x7FFF) * 1000);
347 /* Polar and spherical coordinates are the same for two or less
349 * Note that we also use this case if NO flags are marked.
350 * According to MSDN, we should return the direction in the
351 * format that it was specified in, if no flags are marked.
353 peff
->rglDirection
[0] = (This
->effect
.direction
/ 33) * 36 + 9000;
354 if (peff
->rglDirection
[0] > 35999)
355 peff
->rglDirection
[0] -= 35999;
360 if (dwFlags
& DIEP_DURATION
) {
361 peff
->dwDuration
= (DWORD
)This
->effect
.replay
.length
* 1000;
364 if (dwFlags
& DIEP_ENVELOPE
) {
365 struct ff_envelope
* env
;
366 if (This
->effect
.type
== FF_CONSTANT
) env
= &This
->effect
.u
.constant
.envelope
;
367 else if (This
->effect
.type
== FF_PERIODIC
) env
= &This
->effect
.u
.periodic
.envelope
;
368 else if (This
->effect
.type
== FF_RAMP
) env
= &This
->effect
.u
.ramp
.envelope
;
371 peff
->lpEnvelope
= NULL
;
372 } else if (peff
->lpEnvelope
== NULL
) {
373 return DIERR_INVALIDPARAM
;
375 peff
->lpEnvelope
->dwAttackLevel
= (env
->attack_level
/ 33) * 10;
376 peff
->lpEnvelope
->dwAttackTime
= env
->attack_length
* 1000;
377 peff
->lpEnvelope
->dwFadeLevel
= (env
->fade_level
/ 33) * 10;
378 peff
->lpEnvelope
->dwFadeTime
= env
->fade_length
* 1000;
382 if (dwFlags
& DIEP_GAIN
) {
383 peff
->dwGain
= This
->gain
* 10000 / 0xFFFF;
386 if (dwFlags
& DIEP_SAMPLEPERIOD
) {
387 /* the linux input ff driver has no support for setting
388 * the playback sample period. 0 means default. */
389 peff
->dwSamplePeriod
= 0;
392 if (dwFlags
& DIEP_STARTDELAY
) {
393 peff
->dwStartDelay
= This
->effect
.replay
.delay
* 1000;
396 if (dwFlags
& DIEP_TRIGGERBUTTON
) {
397 FIXME("LinuxInput button mapping needs redoing; for now, assuming we're using an actual joystick.\n");
398 peff
->dwTriggerButton
= DIJOFS_BUTTON(This
->effect
.trigger
.button
- BTN_JOYSTICK
);
401 if (dwFlags
& DIEP_TRIGGERREPEATINTERVAL
) {
402 peff
->dwTriggerRepeatInterval
= This
->effect
.trigger
.interval
* 1000;
405 if (dwFlags
& DIEP_TYPESPECIFICPARAMS
) {
406 DWORD expectedsize
= 0;
407 if (This
->effect
.type
== FF_PERIODIC
) {
408 expectedsize
= sizeof(DIPERIODIC
);
409 } else if (This
->effect
.type
== FF_CONSTANT
) {
410 expectedsize
= sizeof(DICONSTANTFORCE
);
411 } else if (This
->effect
.type
== FF_SPRING
412 || This
->effect
.type
== FF_FRICTION
413 || This
->effect
.type
== FF_INERTIA
414 || This
->effect
.type
== FF_DAMPER
) {
415 expectedsize
= sizeof(DICONDITION
) * 2;
416 } else if (This
->effect
.type
== FF_RAMP
) {
417 expectedsize
= sizeof(DIRAMPFORCE
);
419 if (expectedsize
> peff
->cbTypeSpecificParams
)
420 diErr
= DIERR_MOREDATA
;
421 peff
->cbTypeSpecificParams
= expectedsize
;
425 if (This
->effect
.type
== FF_PERIODIC
) {
426 LPDIPERIODIC tsp
= peff
->lpvTypeSpecificParams
;
427 tsp
->dwMagnitude
= (This
->effect
.u
.periodic
.magnitude
/ 33) * 10;
428 tsp
->lOffset
= (This
->effect
.u
.periodic
.offset
/ 33) * 10;
429 tsp
->dwPhase
= (This
->effect
.u
.periodic
.phase
/ 33) * 36;
430 tsp
->dwPeriod
= (This
->effect
.u
.periodic
.period
* 1000);
431 } else if (This
->effect
.type
== FF_CONSTANT
) {
432 LPDICONSTANTFORCE tsp
= peff
->lpvTypeSpecificParams
;
433 tsp
->lMagnitude
= (This
->effect
.u
.constant
.level
/ 33) * 10;
434 } else if (This
->effect
.type
== FF_SPRING
435 || This
->effect
.type
== FF_FRICTION
436 || This
->effect
.type
== FF_INERTIA
437 || This
->effect
.type
== FF_DAMPER
) {
438 LPDICONDITION tsp
= peff
->lpvTypeSpecificParams
;
440 for (i
= 0; i
< 2; ++i
) {
441 tsp
[i
].lOffset
= (This
->effect
.u
.condition
[i
].center
/ 33) * 10;
442 tsp
[i
].lPositiveCoefficient
= (This
->effect
.u
.condition
[i
].right_coeff
/ 33) * 10;
443 tsp
[i
].lNegativeCoefficient
= (This
->effect
.u
.condition
[i
].left_coeff
/ 33) * 10;
444 tsp
[i
].dwPositiveSaturation
= (This
->effect
.u
.condition
[i
].right_saturation
/ 33) * 10;
445 tsp
[i
].dwNegativeSaturation
= (This
->effect
.u
.condition
[i
].left_saturation
/ 33) * 10;
446 tsp
[i
].lDeadBand
= (This
->effect
.u
.condition
[i
].deadband
/ 33) * 10;
448 } else if (This
->effect
.type
== FF_RAMP
) {
449 LPDIRAMPFORCE tsp
= peff
->lpvTypeSpecificParams
;
450 tsp
->lStart
= (This
->effect
.u
.ramp
.start_level
/ 33) * 10;
451 tsp
->lEnd
= (This
->effect
.u
.ramp
.end_level
/ 33) * 10;
459 static HRESULT WINAPI
LinuxInputEffectImpl_Initialize(
460 LPDIRECTINPUTEFFECT iface
,
465 FIXME("(this=%p,%p,%d,%s): stub!\n",
466 iface
, hinst
, dwVersion
, debugstr_guid(rguid
));
471 static HRESULT WINAPI
LinuxInputEffectImpl_QueryInterface(
472 LPDIRECTINPUTEFFECT iface
,
476 LinuxInputEffectImpl
* This
= (LinuxInputEffectImpl
*)iface
;
478 TRACE("(this=%p,%s,%p)\n", This
, debugstr_guid(riid
), ppvObject
);
480 if (IsEqualGUID(&IID_IUnknown
, riid
) ||
481 IsEqualGUID(&IID_IDirectInputEffect
, riid
)) {
482 LinuxInputEffectImpl_AddRef(iface
);
487 TRACE("Unsupported interface!\n");
491 static HRESULT WINAPI
LinuxInputEffectImpl_Start(
492 LPDIRECTINPUTEFFECT iface
,
496 struct input_event event
;
497 LinuxInputEffectImpl
* This
= (LinuxInputEffectImpl
*)iface
;
499 TRACE("(this=%p,%d,%d)\n", This
, dwIterations
, dwFlags
);
501 if (!(dwFlags
& DIES_NODOWNLOAD
)) {
502 /* Download the effect if necessary */
503 if (This
->effect
.id
== -1) {
504 HRESULT res
= LinuxInputEffectImpl_Download(iface
);
510 if (dwFlags
& DIES_SOLO
) {
511 FIXME("Solo mode requested: should be stopping all effects here!\n");
515 event
.code
= This
->effect
.id
;
516 event
.value
= dwIterations
;
517 if (write(*(This
->fd
), &event
, sizeof(event
)) == -1) {
518 FIXME("Unable to write event. Assuming device disconnected.\n");
519 return DIERR_INPUTLOST
;
525 static HRESULT WINAPI
LinuxInputEffectImpl_SetParameters(
526 LPDIRECTINPUTEFFECT iface
,
530 LinuxInputEffectImpl
* This
= (LinuxInputEffectImpl
*)iface
;
531 DWORD type
= _typeFromGUID(&This
->guid
);
532 HRESULT retval
= DI_OK
;
534 TRACE("(this=%p,%p,%d)\n", This
, peff
, dwFlags
);
536 _dump_DIEFFECT(peff
, &This
->guid
);
538 if ((dwFlags
& ~DIEP_NORESTART
& ~DIEP_NODOWNLOAD
& ~DIEP_START
) == 0) {
540 dwFlags
= DIEP_AXES
| DIEP_DIRECTION
| DIEP_DURATION
| DIEP_ENVELOPE
|
541 DIEP_GAIN
| DIEP_SAMPLEPERIOD
| DIEP_STARTDELAY
| DIEP_TRIGGERBUTTON
|
542 DIEP_TRIGGERREPEATINTERVAL
| DIEP_TYPESPECIFICPARAMS
;
545 if (dwFlags
& DIEP_AXES
) {
546 /* the linux input effect system only supports one or two axes */
548 return DIERR_INVALIDPARAM
;
549 else if (peff
->cAxes
< 1)
550 return DIERR_INCOMPLETEEFFECT
;
553 /* some of this may look funky, but it's 'cause the linux driver and directx have
554 * different opinions about which way direction "0" is. directx has 0 along the x
555 * axis (left), linux has it along the y axis (down). */
556 if (dwFlags
& DIEP_DIRECTION
) {
557 if (peff
->cAxes
== 1) {
558 if (peff
->dwFlags
& DIEFF_CARTESIAN
) {
559 if (dwFlags
& DIEP_AXES
) {
560 if (peff
->rgdwAxes
[0] == DIJOFS_X
&& peff
->rglDirection
[0] >= 0)
561 This
->effect
.direction
= 0x4000;
562 else if (peff
->rgdwAxes
[0] == DIJOFS_X
&& peff
->rglDirection
[0] < 0)
563 This
->effect
.direction
= 0xC000;
564 else if (peff
->rgdwAxes
[0] == DIJOFS_Y
&& peff
->rglDirection
[0] >= 0)
565 This
->effect
.direction
= 0;
566 else if (peff
->rgdwAxes
[0] == DIJOFS_Y
&& peff
->rglDirection
[0] < 0)
567 This
->effect
.direction
= 0x8000;
570 /* one-axis effects must use cartesian coords */
571 return DIERR_INVALIDPARAM
;
573 } else { /* two axes */
574 if (peff
->dwFlags
& DIEFF_CARTESIAN
) {
575 /* avoid divide-by-zero */
576 if (peff
->rglDirection
[1] == 0) {
577 if (peff
->rglDirection
[0] >= 0)
578 This
->effect
.direction
= 0x4000;
579 else if (peff
->rglDirection
[0] < 0)
580 This
->effect
.direction
= 0xC000;
582 This
->effect
.direction
= (int)(atan(peff
->rglDirection
[0] / peff
->rglDirection
[1]) * 0x7FFF / (3 * M_PI
));
585 /* Polar and spherical are the same for 2 axes */
586 /* Precision is important here, so we do double math with exact constants */
587 This
->effect
.direction
= (int)(((double)peff
->rglDirection
[0] - 90) / 35999) * 0x7FFF;
592 if (dwFlags
& DIEP_DURATION
)
593 This
->effect
.replay
.length
= peff
->dwDuration
/ 1000;
595 if (dwFlags
& DIEP_ENVELOPE
) {
596 struct ff_envelope
* env
;
597 if (This
->effect
.type
== FF_CONSTANT
) env
= &This
->effect
.u
.constant
.envelope
;
598 else if (This
->effect
.type
== FF_PERIODIC
) env
= &This
->effect
.u
.periodic
.envelope
;
599 else if (This
->effect
.type
== FF_RAMP
) env
= &This
->effect
.u
.ramp
.envelope
;
602 if (peff
->lpEnvelope
== NULL
) {
603 /* if this type had an envelope, reset it
604 * note that length can never be zero, so we set it to something minuscule */
606 env
->attack_length
= 0x10;
607 env
->attack_level
= 0x7FFF;
608 env
->fade_length
= 0x10;
609 env
->fade_level
= 0x7FFF;
612 /* did we get passed an envelope for a type that doesn't even have one? */
613 if (!env
) return DIERR_INVALIDPARAM
;
614 /* copy the envelope */
615 env
->attack_length
= peff
->lpEnvelope
->dwAttackTime
/ 1000;
616 env
->attack_level
= (peff
->lpEnvelope
->dwAttackLevel
/ 10) * 32;
617 env
->fade_length
= peff
->lpEnvelope
->dwFadeTime
/ 1000;
618 env
->fade_level
= (peff
->lpEnvelope
->dwFadeLevel
/ 10) * 32;
622 /* Gain and Sample Period settings are not supported by the linux
624 if (dwFlags
& DIEP_GAIN
) {
625 This
->gain
= 0xFFFF * peff
->dwGain
/ 10000;
626 TRACE("Effect gain requested but no effect gain functionality present.\n");
629 if (dwFlags
& DIEP_SAMPLEPERIOD
)
630 TRACE("Sample period requested but no sample period functionality present.\n");
632 if (dwFlags
& DIEP_STARTDELAY
)
633 This
->effect
.replay
.delay
= peff
->dwStartDelay
/ 1000;
635 if (dwFlags
& DIEP_TRIGGERBUTTON
) {
636 if (peff
->dwTriggerButton
!= -1) {
637 FIXME("Linuxinput button mapping needs redoing, assuming we're using a joystick.\n");
638 FIXME("Trigger button translation not yet implemented!\n");
640 This
->effect
.trigger
.button
= 0;
643 if (dwFlags
& DIEP_TRIGGERREPEATINTERVAL
)
644 This
->effect
.trigger
.interval
= peff
->dwTriggerRepeatInterval
/ 1000;
646 if (dwFlags
& DIEP_TYPESPECIFICPARAMS
) {
647 if (!(peff
->lpvTypeSpecificParams
))
648 return DIERR_INCOMPLETEEFFECT
;
649 if (type
== DIEFT_PERIODIC
) {
651 if (peff
->cbTypeSpecificParams
!= sizeof(DIPERIODIC
))
652 return DIERR_INVALIDPARAM
;
653 tsp
= peff
->lpvTypeSpecificParams
;
654 This
->effect
.u
.periodic
.magnitude
= (tsp
->dwMagnitude
/ 10) * 32;
655 This
->effect
.u
.periodic
.offset
= (tsp
->lOffset
/ 10) * 32;
656 This
->effect
.u
.periodic
.phase
= (tsp
->dwPhase
/ 9) * 8; /* == (/ 36 * 32) */
657 This
->effect
.u
.periodic
.period
= tsp
->dwPeriod
/ 1000;
658 } else if (type
== DIEFT_CONSTANTFORCE
) {
659 LPCDICONSTANTFORCE tsp
;
660 if (peff
->cbTypeSpecificParams
!= sizeof(DICONSTANTFORCE
))
661 return DIERR_INVALIDPARAM
;
662 tsp
= peff
->lpvTypeSpecificParams
;
663 This
->effect
.u
.constant
.level
= (max(min(tsp
->lMagnitude
, 10000), -10000) / 10) * 32;
664 } else if (type
== DIEFT_RAMPFORCE
) {
666 if (peff
->cbTypeSpecificParams
!= sizeof(DIRAMPFORCE
))
667 return DIERR_INVALIDPARAM
;
668 tsp
= peff
->lpvTypeSpecificParams
;
669 This
->effect
.u
.ramp
.start_level
= (tsp
->lStart
/ 10) * 32;
670 This
->effect
.u
.ramp
.end_level
= (tsp
->lStart
/ 10) * 32;
671 } else if (type
== DIEFT_CONDITION
) {
672 LPCDICONDITION tsp
= peff
->lpvTypeSpecificParams
;
673 if (peff
->cbTypeSpecificParams
== sizeof(DICONDITION
)) {
674 /* One condition block. This needs to be rotated to direction,
675 * and expanded to separate x and y conditions. */
678 factor
[0] = asin((This
->effect
.direction
* 3.0 * M_PI
) / 0x7FFF);
679 factor
[1] = acos((This
->effect
.direction
* 3.0 * M_PI
) / 0x7FFF);
680 for (i
= 0; i
< 2; ++i
) {
681 This
->effect
.u
.condition
[i
].center
= (int)(factor
[i
] * (tsp
->lOffset
/ 10) * 32);
682 This
->effect
.u
.condition
[i
].right_coeff
= (int)(factor
[i
] * (tsp
->lPositiveCoefficient
/ 10) * 32);
683 This
->effect
.u
.condition
[i
].left_coeff
= (int)(factor
[i
] * (tsp
->lNegativeCoefficient
/ 10) * 32);
684 This
->effect
.u
.condition
[i
].right_saturation
= (int)(factor
[i
] * (tsp
->dwPositiveSaturation
/ 10) * 32);
685 This
->effect
.u
.condition
[i
].left_saturation
= (int)(factor
[i
] * (tsp
->dwNegativeSaturation
/ 10) * 32);
686 This
->effect
.u
.condition
[i
].deadband
= (int)(factor
[i
] * (tsp
->lDeadBand
/ 10) * 32);
688 } else if (peff
->cbTypeSpecificParams
== 2 * sizeof(DICONDITION
)) {
689 /* Two condition blocks. Direct parameter copy. */
691 for (i
= 0; i
< 2; ++i
) {
692 This
->effect
.u
.condition
[i
].center
= (tsp
[i
].lOffset
/ 10) * 32;
693 This
->effect
.u
.condition
[i
].right_coeff
= (tsp
[i
].lPositiveCoefficient
/ 10) * 32;
694 This
->effect
.u
.condition
[i
].left_coeff
= (tsp
[i
].lNegativeCoefficient
/ 10) * 32;
695 This
->effect
.u
.condition
[i
].right_saturation
= (tsp
[i
].dwPositiveSaturation
/ 10) * 32;
696 This
->effect
.u
.condition
[i
].left_saturation
= (tsp
[i
].dwNegativeSaturation
/ 10) * 32;
697 This
->effect
.u
.condition
[i
].deadband
= (tsp
[i
].lDeadBand
/ 10) * 32;
700 return DIERR_INVALIDPARAM
;
703 FIXME("Custom force types are not supported\n");
704 return DIERR_INVALIDPARAM
;
708 if (!(dwFlags
& DIEP_NODOWNLOAD
))
709 retval
= LinuxInputEffectImpl_Download(iface
);
711 return DI_DOWNLOADSKIPPED
;
713 if (dwFlags
& DIEP_NORESTART
)
714 TRACE("DIEP_NORESTART: not handled (we have no control of that).\n");
716 if (dwFlags
& DIEP_START
)
717 retval
= LinuxInputEffectImpl_Start(iface
, 1, 0);
724 static HRESULT WINAPI
LinuxInputEffectImpl_Stop(
725 LPDIRECTINPUTEFFECT iface
)
727 struct input_event event
;
728 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
730 TRACE("(this=%p)\n", This
);
733 event
.code
= This
->effect
.id
;
735 /* we don't care about the success or failure of this call */
736 write(*(This
->fd
), &event
, sizeof(event
));
741 static HRESULT WINAPI
LinuxInputEffectImpl_Unload(
742 LPDIRECTINPUTEFFECT iface
)
744 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
745 TRACE("(this=%p)\n", This
);
747 /* Erase the downloaded effect */
748 if (ioctl(*(This
->fd
), EVIOCRMFF
, This
->effect
.id
) == -1)
749 return DIERR_INVALIDPARAM
;
751 /* Mark the effect as deallocated */
752 This
->effect
.id
= -1;
757 static ULONG WINAPI
LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface
)
759 LinuxInputEffectImpl
*This
= (LinuxInputEffectImpl
*)iface
;
760 ULONG ref
= InterlockedDecrement(&(This
->ref
));
764 LinuxInputEffectImpl_Stop(iface
);
765 LinuxInputEffectImpl_Unload(iface
);
766 list_remove(This
->entry
);
767 HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This
->entry
, effect_list_item
, entry
));
768 HeapFree(GetProcessHeap(), 0, This
);
773 /******************************************************************************
777 HRESULT
linuxinput_create_effect(
780 struct list
*parent_list_entry
,
781 LPDIRECTINPUTEFFECT
* peff
)
783 LinuxInputEffectImpl
* newEffect
= HeapAlloc(GetProcessHeap(),
784 HEAP_ZERO_MEMORY
, sizeof(LinuxInputEffectImpl
));
785 DWORD type
= _typeFromGUID(rguid
);
787 newEffect
->lpVtbl
= &LinuxInputEffectVtbl
;
789 newEffect
->guid
= *rguid
;
791 newEffect
->gain
= 0xFFFF;
793 /* set the type. this cannot be changed over the effect's life. */
796 newEffect
->effect
.type
= FF_PERIODIC
;
797 if (IsEqualGUID(rguid
, &GUID_Sine
)) {
798 newEffect
->effect
.u
.periodic
.waveform
= FF_SINE
;
799 } else if (IsEqualGUID(rguid
, &GUID_Triangle
)) {
800 newEffect
->effect
.u
.periodic
.waveform
= FF_TRIANGLE
;
801 } else if (IsEqualGUID(rguid
, &GUID_Square
)) {
802 newEffect
->effect
.u
.periodic
.waveform
= FF_SQUARE
;
803 } else if (IsEqualGUID(rguid
, &GUID_SawtoothUp
)) {
804 newEffect
->effect
.u
.periodic
.waveform
= FF_SAW_UP
;
805 } else if (IsEqualGUID(rguid
, &GUID_SawtoothDown
)) {
806 newEffect
->effect
.u
.periodic
.waveform
= FF_SAW_DOWN
;
809 case DIEFT_CONSTANTFORCE
:
810 newEffect
->effect
.type
= FF_CONSTANT
;
812 case DIEFT_RAMPFORCE
:
813 newEffect
->effect
.type
= FF_RAMP
;
815 case DIEFT_CONDITION
:
816 if (IsEqualGUID(rguid
, &GUID_Spring
)) {
817 newEffect
->effect
.type
= FF_SPRING
;
818 } else if (IsEqualGUID(rguid
, &GUID_Friction
)) {
819 newEffect
->effect
.type
= FF_FRICTION
;
820 } else if (IsEqualGUID(rguid
, &GUID_Inertia
)) {
821 newEffect
->effect
.type
= FF_INERTIA
;
822 } else if (IsEqualGUID(rguid
, &GUID_Damper
)) {
823 newEffect
->effect
.type
= FF_DAMPER
;
826 case DIEFT_CUSTOMFORCE
:
827 FIXME("Custom forces are not supported.\n");
828 HeapFree(GetProcessHeap(), 0, newEffect
);
829 return DIERR_INVALIDPARAM
;
831 FIXME("Unknown force type 0x%x.\n", type
);
832 HeapFree(GetProcessHeap(), 0, newEffect
);
833 return DIERR_INVALIDPARAM
;
836 /* mark as non-uploaded */
837 newEffect
->effect
.id
= -1;
839 newEffect
->entry
= parent_list_entry
;
841 *peff
= (LPDIRECTINPUTEFFECT
)newEffect
;
843 TRACE("Creating linux input system effect (%p) with guid %s\n",
844 *peff
, _dump_dinput_GUID(rguid
));
849 HRESULT
linuxinput_get_info_A(
852 LPDIEFFECTINFOA info
)
854 DWORD type
= _typeFromGUID(rguid
);
856 TRACE("(%d, %s, %p) type=%d\n", fd
, _dump_dinput_GUID(rguid
), info
, type
);
858 if (!info
) return E_POINTER
;
860 if (info
->dwSize
!= sizeof(DIEFFECTINFOA
)) return DIERR_INVALIDPARAM
;
864 info
->dwEffType
= type
;
865 /* the event device API does not support querying for all these things
866 * therefore we assume that we have support for them
867 * that's not as dangerous as it sounds, since drivers are allowed to
868 * ignore parameters they claim to support anyway */
869 info
->dwEffType
|= DIEFT_DEADBAND
| DIEFT_FFATTACK
| DIEFT_FFFADE
870 | DIEFT_POSNEGCOEFFICIENTS
| DIEFT_POSNEGSATURATION
871 | DIEFT_SATURATION
| DIEFT_STARTDELAY
;
873 /* again, assume we have support for everything */
874 info
->dwStaticParams
= DIEP_ALLPARAMS
;
875 info
->dwDynamicParams
= info
->dwStaticParams
;
877 /* yes, this is windows behavior (print the GUID_Name for name) */
878 strcpy(info
->tszName
, _dump_dinput_GUID(rguid
));
883 HRESULT
linuxinput_get_info_W(
886 LPDIEFFECTINFOW info
)
888 DWORD type
= _typeFromGUID(rguid
);
890 TRACE("(%d, %s, %p) type=%d\n", fd
, _dump_dinput_GUID(rguid
), info
, type
);
892 if (!info
) return E_POINTER
;
894 if (info
->dwSize
!= sizeof(DIEFFECTINFOW
)) return DIERR_INVALIDPARAM
;
898 info
->dwEffType
= type
;
899 /* the event device API does not support querying for all these things
900 * therefore we assume that we have support for them
901 * that's not as dangerous as it sounds, since drivers are allowed to
902 * ignore parameters they claim to support anyway */
903 info
->dwEffType
|= DIEFT_DEADBAND
| DIEFT_FFATTACK
| DIEFT_FFFADE
904 | DIEFT_POSNEGCOEFFICIENTS
| DIEFT_POSNEGSATURATION
905 | DIEFT_SATURATION
| DIEFT_STARTDELAY
;
907 /* again, assume we have support for everything */
908 info
->dwStaticParams
= DIEP_ALLPARAMS
;
909 info
->dwDynamicParams
= info
->dwStaticParams
;
911 /* yes, this is windows behavior (print the GUID_Name for name) */
912 MultiByteToWideChar(CP_ACP
, 0, _dump_dinput_GUID(rguid
), -1,
913 info
->tszName
, MAX_PATH
);
918 static const IDirectInputEffectVtbl LinuxInputEffectVtbl
= {
919 LinuxInputEffectImpl_QueryInterface
,
920 LinuxInputEffectImpl_AddRef
,
921 LinuxInputEffectImpl_Release
,
922 LinuxInputEffectImpl_Initialize
,
923 LinuxInputEffectImpl_GetEffectGuid
,
924 LinuxInputEffectImpl_GetParameters
,
925 LinuxInputEffectImpl_SetParameters
,
926 LinuxInputEffectImpl_Start
,
927 LinuxInputEffectImpl_Stop
,
928 LinuxInputEffectImpl_GetEffectStatus
,
929 LinuxInputEffectImpl_Download
,
930 LinuxInputEffectImpl_Unload
,
931 LinuxInputEffectImpl_Escape
934 #endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */