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