Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939/* DirectInput Linux Event Device Effect * * Copyright 2005 Daniel Remenak * * Thanks to Google's Summer of Code Program (2005) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
#include "config.h"
#ifdef HAVE_STRUCT_FF_EFFECT_DIRECTION
#include <stdarg.h>#include <string.h>#ifdef HAVE_LINUX_INPUT_H# include <linux/input.h># undef SW_MAX#endif#include <limits.h>#include <errno.h>#ifdef HAVE_UNISTD_H# include <unistd.h>#endif#include <math.h>#include "wine/debug.h"#include "wine/unicode.h"#include "windef.h"#include "winbase.h"#include "winerror.h"#include "dinput.h"
#include "device_private.h"#include "joystick_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(dinput);
static const IDirectInputEffectVtbl LinuxInputEffectVtbl;typedef struct LinuxInputEffectImpl LinuxInputEffectImpl;struct LinuxInputEffectImpl{ IDirectInputEffect IDirectInputEffect_iface; LONG ref; GUID guid;
struct ff_effect effect; /* Effect data */ int gain; /* Effect gain */ BOOL first_axis_is_x; int* fd; /* Parent device */ struct list *entry; /* Entry into the parent's list of effects */};
static inline LinuxInputEffectImpl *impl_from_IDirectInputEffect(IDirectInputEffect *iface){ return CONTAINING_RECORD(iface, LinuxInputEffectImpl, IDirectInputEffect_iface);}
static double ff_effect_direction_to_rad(unsigned int dir){ return (dir & 0xffff) * M_PI / 0x8000;}
static void ff_dump_effect(struct ff_effect *effect){ const char *type = "(Unknown)", *length = "INFINITE"; struct ff_envelope *env = NULL; double angle;#define FE(x) case x: type = #x; break switch (effect->type) { FE(FF_RUMBLE); FE(FF_PERIODIC); FE(FF_CONSTANT); FE(FF_SPRING); FE(FF_FRICTION); FE(FF_DAMPER); FE(FF_INERTIA); FE(FF_RAMP); }#undef FE
/* rotate so 0 points right */ angle = 360 - ff_effect_direction_to_rad(effect->direction + 0xc000) * 180 / M_PI;
if (effect->replay.length) length = wine_dbg_sprintf("%u ms", effect->replay.length);
TRACE("type 0x%x %s, id %d, direction 0x%x (source angle %.2f), time length %s, start delay %u ms\n", effect->type, type, effect->id, effect->direction, angle, length, effect->replay.delay); if (effect->trigger.button || effect->trigger.interval) TRACE(" -> trigger button %u, re-trigger interval %u ms\n", effect->trigger.button, effect->trigger.interval);
if (effect->type == FF_PERIODIC) { struct ff_periodic_effect *per = &effect->u.periodic; const char *wave = "(Unknown)";#define FE(x) case x: wave = #x; break switch (per->waveform) { FE(FF_SQUARE); FE(FF_TRIANGLE); FE(FF_SINE); FE(FF_SAW_UP); FE(FF_SAW_DOWN); FE(FF_CUSTOM); }#undef FE angle = ff_effect_direction_to_rad(per->phase) * 180 / M_PI; TRACE(" -> waveform 0x%x %s, period %u ms, magnitude %d, offset %d, phase 0x%x (angle %.2f), custom len %d\n", per->waveform, wave, per->period, per->magnitude, per->offset, per->phase, angle, per->custom_len); env = &per->envelope; } else if (effect->type == FF_CONSTANT) { struct ff_constant_effect *cons = &effect->u.constant; TRACE(" -> level %d\n", cons->level); env = &cons->envelope; } else if (effect->type == FF_RAMP) { struct ff_ramp_effect *ramp = &effect->u.ramp; TRACE(" -> start/end level %d/%d\n", ramp->start_level, ramp->end_level); env = &ramp->envelope; } else if (effect->type == FF_RUMBLE) { struct ff_rumble_effect *rumble = &effect->u.rumble; TRACE(" -> strong/weak magnitude %u/%u\n", rumble->strong_magnitude, rumble->weak_magnitude); } else if (effect->type == FF_SPRING || effect->type == FF_FRICTION || effect->type == FF_DAMPER || effect->type == FF_INERTIA) { struct ff_condition_effect *cond = effect->u.condition; int i; for (i = 0; i < 2; i++) { /* format numbers here to make them align correctly */ TRACE(" -> [%d] right/left saturation %5u/%5u, right/left coefficient %5d/%5d," " deadband %5u, center %5d\n", i, cond[i].right_saturation, cond[i].left_saturation, cond[i].right_coeff, cond[i].left_coeff, cond[i].deadband, cond[i].center); } }
if (env) TRACE(" -> envelope attack length(ms)/level %u/%u, fade length(ms)/level %u/%u\n", env->attack_length, env->attack_level, env->fade_length, env->fade_level);}
/****************************************************************************** * LinuxInputEffectImpl */
static ULONG WINAPI LinuxInputEffectImpl_AddRef( LPDIRECTINPUTEFFECT iface){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); ULONG ref = InterlockedIncrement(&This->ref); TRACE( "(%p) ref %d\n", This, ref ); return ref;}
static HRESULT WINAPI LinuxInputEffectImpl_Download( LPDIRECTINPUTEFFECT iface){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); int ret, old_effect_id;
TRACE("(this=%p)\n", This); ff_dump_effect(&This->effect);
old_effect_id = This->effect.id; if (ioctl(*(This->fd), EVIOCSFF, &This->effect) != -1) return DI_OK;
/* Linux kernel < 3.14 has a bug that incorrectly assigns an effect ID even * on error, restore it here if that is the case. */ This->effect.id = old_effect_id;
switch (errno) { case EINVAL: ret = DIERR_INVALIDPARAM; break; case ENOSPC: ret = DIERR_DEVICEFULL; break; case ENOMEM: ret = DIERR_OUTOFMEMORY; break; default: ret = DIERR_INPUTLOST; break; } TRACE("Could not upload effect to fd %d, errno %d \"%s\", returning 0x%x.\n", *This->fd, errno, strerror(errno), ret); return ret;}
static HRESULT WINAPI LinuxInputEffectImpl_Escape( LPDIRECTINPUTEFFECT iface, LPDIEFFESCAPE pesc){ WARN("(this=%p,%p): invalid: no hardware-specific escape codes in this" " driver!\n", iface, pesc);
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_GetEffectGuid( LPDIRECTINPUTEFFECT iface, LPGUID pguid){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
TRACE("(this=%p,%p)\n", This, pguid);
*pguid = This->guid;
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_GetEffectStatus( LPDIRECTINPUTEFFECT iface, LPDWORD pdwFlags){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
TRACE("(this=%p,%p)\n", This, pdwFlags);
if (!pdwFlags) return E_POINTER;
if (This->effect.id == -1) return DIERR_NOTDOWNLOADED;
/* linux sends the effect status through an event. * that event is trapped by our parent joystick driver * and there is no clean way to pass it back to us. */ FIXME("Not enough information to provide a status.\n");
(*pdwFlags) = 0;
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_GetParameters( LPDIRECTINPUTEFFECT iface, LPDIEFFECT peff, DWORD dwFlags){ HRESULT diErr = DI_OK; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
/* Major conversion factors are: * times: millisecond (linux) -> microsecond (windows) (x * 1000) * forces: scale 0x7FFF (linux) -> scale 10000 (windows) approx ((x / 33) * 10) * angles: scale 0x7FFF (linux) -> scale 35999 (windows) approx ((x / 33) * 36) * angle bases: 0 -> -y (down) (linux) -> 0 -> +x (right) (windows) */
if (dwFlags & DIEP_AXES) { if (peff->cAxes < 2 /* linuxinput effects always use 2 axes, x and y */) diErr = DIERR_MOREDATA; peff->cAxes = 2; if (diErr) return diErr; else { peff->rgdwAxes[0] = DIJOFS_X; peff->rgdwAxes[1] = DIJOFS_Y; } } if (dwFlags & DIEP_DIRECTION) { if (peff->cAxes < 2) diErr = DIERR_MOREDATA; peff->cAxes = 2; if (diErr) return diErr; else { if (peff->dwFlags & DIEFF_CARTESIAN) { /* rotate so 0 points right */ double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000); peff->rglDirection[0] = sin(angle) * 1000; peff->rglDirection[1] = -cos(angle) * 1000; } else { /* Polar and spherical coordinates are the same for two or less * axes. * Note that we also use this case if NO flags are marked. * According to MSDN, we should return the direction in the * format that it was specified in, if no flags are marked. */ peff->rglDirection[0] = (This->effect.direction / 33) * 36 + 9000; if (peff->rglDirection[0] > 35999) peff->rglDirection[0] -= 35999; } } }
if (dwFlags & DIEP_DURATION) { if (!This->effect.replay.length) /* infinite for the linux driver */ peff->dwDuration = INFINITE; else peff->dwDuration = (DWORD)This->effect.replay.length * 1000; }
if (dwFlags & DIEP_ENVELOPE) { struct ff_envelope* env; if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope; else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope; else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope; else env = NULL; if (env == NULL) { peff->lpEnvelope = NULL; } else if (peff->lpEnvelope == NULL) { return DIERR_INVALIDPARAM; } else { peff->lpEnvelope->dwAttackLevel = (env->attack_level / 33) * 10; peff->lpEnvelope->dwAttackTime = env->attack_length * 1000; peff->lpEnvelope->dwFadeLevel = (env->fade_level / 33) * 10; peff->lpEnvelope->dwFadeTime = env->fade_length * 1000; } }
if (dwFlags & DIEP_GAIN) { peff->dwGain = This->gain * 10000 / 0xFFFF; }
if (dwFlags & DIEP_SAMPLEPERIOD) { /* the linux input ff driver has no support for setting * the playback sample period. 0 means default. */ peff->dwSamplePeriod = 0; }
if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5)) peff->dwStartDelay = This->effect.replay.delay * 1000;
if (dwFlags & DIEP_TRIGGERBUTTON) { FIXME("LinuxInput button mapping needs redoing; for now, assuming we're using an actual joystick.\n"); peff->dwTriggerButton = DIJOFS_BUTTON(This->effect.trigger.button - BTN_JOYSTICK); }
if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) { peff->dwTriggerRepeatInterval = This->effect.trigger.interval * 1000; }
if (dwFlags & DIEP_TYPESPECIFICPARAMS) { DWORD expectedsize = 0; if (This->effect.type == FF_PERIODIC) { expectedsize = sizeof(DIPERIODIC); } else if (This->effect.type == FF_CONSTANT) { expectedsize = sizeof(DICONSTANTFORCE); } else if (This->effect.type == FF_SPRING || This->effect.type == FF_FRICTION || This->effect.type == FF_INERTIA || This->effect.type == FF_DAMPER) { expectedsize = sizeof(DICONDITION) * 2; } else if (This->effect.type == FF_RAMP) { expectedsize = sizeof(DIRAMPFORCE); } if (expectedsize > peff->cbTypeSpecificParams) diErr = DIERR_MOREDATA; peff->cbTypeSpecificParams = expectedsize; if (diErr) return diErr; else { if (This->effect.type == FF_PERIODIC) { LPDIPERIODIC tsp = peff->lpvTypeSpecificParams; tsp->dwMagnitude = (This->effect.u.periodic.magnitude / 33) * 10; tsp->lOffset = (This->effect.u.periodic.offset / 33) * 10; tsp->dwPhase = (This->effect.u.periodic.phase / 33) * 36; tsp->dwPeriod = (This->effect.u.periodic.period * 1000); } else if (This->effect.type == FF_CONSTANT) { LPDICONSTANTFORCE tsp = peff->lpvTypeSpecificParams; tsp->lMagnitude = (This->effect.u.constant.level / 33) * 10; } else if (This->effect.type == FF_SPRING || This->effect.type == FF_FRICTION || This->effect.type == FF_INERTIA || This->effect.type == FF_DAMPER) { LPDICONDITION tsp = peff->lpvTypeSpecificParams; int i; for (i = 0; i < 2; ++i) { tsp[i].lOffset = (This->effect.u.condition[i].center / 33) * 10; tsp[i].lPositiveCoefficient = (This->effect.u.condition[i].right_coeff / 33) * 10; tsp[i].lNegativeCoefficient = (This->effect.u.condition[i].left_coeff / 33) * 10; tsp[i].dwPositiveSaturation = (This->effect.u.condition[i].right_saturation / 33) * 10; tsp[i].dwNegativeSaturation = (This->effect.u.condition[i].left_saturation / 33) * 10; tsp[i].lDeadBand = (This->effect.u.condition[i].deadband / 33) * 10; } } else if (This->effect.type == FF_RAMP) { LPDIRAMPFORCE tsp = peff->lpvTypeSpecificParams; tsp->lStart = (This->effect.u.ramp.start_level / 33) * 10; tsp->lEnd = (This->effect.u.ramp.end_level / 33) * 10; } } }
return diErr;}
static HRESULT WINAPI LinuxInputEffectImpl_Initialize( LPDIRECTINPUTEFFECT iface, HINSTANCE hinst, DWORD dwVersion, REFGUID rguid){ FIXME("(this=%p,%p,%d,%s): stub!\n", iface, hinst, dwVersion, debugstr_guid(rguid));
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_QueryInterface( LPDIRECTINPUTEFFECT iface, REFIID riid, void **ppvObject){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
TRACE("(this=%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject);
if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDirectInputEffect, riid)) { LinuxInputEffectImpl_AddRef(iface); *ppvObject = This; return 0; }
TRACE("Unsupported interface!\n"); return E_FAIL;}
static HRESULT WINAPI LinuxInputEffectImpl_Start( LPDIRECTINPUTEFFECT iface, DWORD dwIterations, DWORD dwFlags){ struct input_event event; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
TRACE("(this=%p,%d,%d)\n", This, dwIterations, dwFlags);
if (!(dwFlags & DIES_NODOWNLOAD)) { /* Download the effect if necessary */ if (This->effect.id == -1) { HRESULT res = LinuxInputEffectImpl_Download(iface); if (res != DI_OK) return res; } }
if (dwFlags & DIES_SOLO) { FIXME("Solo mode requested: should be stopping all effects here!\n"); }
event.type = EV_FF; event.code = This->effect.id; event.value = min( dwIterations, INT_MAX ); if (write(*(This->fd), &event, sizeof(event)) == -1) { FIXME("Unable to write event. Assuming device disconnected.\n"); return DIERR_INPUTLOST; }
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_SetParameters( LPDIRECTINPUTEFFECT iface, LPCDIEFFECT peff, DWORD dwFlags){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); DWORD type = typeFromGUID(&This->guid); HRESULT retval = DI_OK;
TRACE("(this=%p,%p,%d)\n", This, peff, dwFlags);
dump_DIEFFECT(peff, &This->guid, dwFlags);
if ((dwFlags & ~DIEP_NORESTART & ~DIEP_NODOWNLOAD & ~DIEP_START) == 0) { /* set everything */ dwFlags = DIEP_AXES | DIEP_DIRECTION | DIEP_DURATION | DIEP_ENVELOPE | DIEP_GAIN | DIEP_SAMPLEPERIOD | DIEP_STARTDELAY | DIEP_TRIGGERBUTTON | DIEP_TRIGGERREPEATINTERVAL | DIEP_TYPESPECIFICPARAMS; }
if (dwFlags & DIEP_AXES) { /* the linux input effect system only supports one or two axes */ if (peff->cAxes > 2) return DIERR_INVALIDPARAM; else if (peff->cAxes < 1) return DIERR_INCOMPLETEEFFECT; This->first_axis_is_x = peff->rgdwAxes[0] == DIJOFS_X; }
/* some of this may look funky, but it's 'cause the linux driver and directx have * different opinions about which way direction "0" is. directx has 0 along the x * axis (left), linux has it along the y axis (down). */ if (dwFlags & DIEP_DIRECTION) { if (peff->cAxes == 1) { if (peff->dwFlags & DIEFF_CARTESIAN) { if (dwFlags & DIEP_AXES) { if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] >= 0) This->effect.direction = 0x4000; else if (peff->rgdwAxes[0] == DIJOFS_X && peff->rglDirection[0] < 0) This->effect.direction = 0xC000; else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] >= 0) This->effect.direction = 0; else if (peff->rgdwAxes[0] == DIJOFS_Y && peff->rglDirection[0] < 0) This->effect.direction = 0x8000; } } else { /* one-axis effects must use cartesian coords */ return DIERR_INVALIDPARAM; } } /* two axes */ else { if (peff->dwFlags & DIEFF_CARTESIAN) { LONG x, y; if (This->first_axis_is_x) { x = peff->rglDirection[0]; y = peff->rglDirection[1]; } else { x = peff->rglDirection[1]; y = peff->rglDirection[0]; } This->effect.direction = (unsigned int)((M_PI / 2 + atan2(y, x)) * 0x8000 / M_PI); } else { /* Polar and spherical are the same for 2 axes */ /* Precision is important here, so we do double math with exact constants */ This->effect.direction = (unsigned int)(((double)peff->rglDirection[0] / 18000) * 0x8000); } } }
if (dwFlags & DIEP_DURATION) { if (peff->dwDuration == INFINITE) This->effect.replay.length = 0; /* infinite for the linux driver */ else if(peff->dwDuration > 1000) This->effect.replay.length = peff->dwDuration / 1000; else This->effect.replay.length = 1; }
if (dwFlags & DIEP_ENVELOPE) { struct ff_envelope* env; if (This->effect.type == FF_CONSTANT) env = &This->effect.u.constant.envelope; else if (This->effect.type == FF_PERIODIC) env = &This->effect.u.periodic.envelope; else if (This->effect.type == FF_RAMP) env = &This->effect.u.ramp.envelope; else env = NULL;
/* copy the envelope if it is present and the linux effect supports it */ if (peff->lpEnvelope && env) { env->attack_length = peff->lpEnvelope->dwAttackTime / 1000; env->attack_level = (peff->lpEnvelope->dwAttackLevel / 10) * 32; env->fade_length = peff->lpEnvelope->dwFadeTime / 1000; env->fade_level = (peff->lpEnvelope->dwFadeLevel / 10) * 32; } /* if the dinput envelope is NULL we will clear the linux envelope */ else if (env) { env->attack_length = 0; env->attack_level = 0; env->fade_length = 0; env->fade_level = 0; } else if(peff->lpEnvelope) { if(peff->lpEnvelope->dwAttackTime || peff->lpEnvelope->dwAttackLevel || peff->lpEnvelope->dwFadeTime || peff->lpEnvelope->dwFadeLevel) WARN("Ignoring dinput envelope not supported in the linux effect\n"); } }
/* Gain and Sample Period settings are not supported by the linux * event system */ if (dwFlags & DIEP_GAIN) { This->gain = 0xFFFF * peff->dwGain / 10000; TRACE("Effect gain requested but no effect gain functionality present.\n"); }
if (dwFlags & DIEP_SAMPLEPERIOD) TRACE("Sample period requested but no sample period functionality present.\n");
if (dwFlags & DIEP_STARTDELAY) if ((dwFlags & DIEP_STARTDELAY) && peff->dwSize > sizeof(DIEFFECT_DX5)) This->effect.replay.delay = peff->dwStartDelay / 1000;
if (dwFlags & DIEP_TRIGGERBUTTON) { if (peff->dwTriggerButton != -1) { FIXME("Linuxinput button mapping needs redoing, assuming we're using a joystick.\n"); FIXME("Trigger button translation not yet implemented!\n"); } This->effect.trigger.button = 0; }
if (dwFlags & DIEP_TRIGGERREPEATINTERVAL) This->effect.trigger.interval = peff->dwTriggerRepeatInterval / 1000;
if (dwFlags & DIEP_TYPESPECIFICPARAMS) { if (!(peff->lpvTypeSpecificParams)) return DIERR_INCOMPLETEEFFECT;
if (type == DIEFT_PERIODIC) { DIPERIODIC *tsp; if (peff->cbTypeSpecificParams != sizeof(DIPERIODIC)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams;
This->effect.u.periodic.magnitude = (tsp->dwMagnitude / 10) * 32; This->effect.u.periodic.offset = (tsp->lOffset / 10) * 32; /* phase ranges from 0 - 35999 in dinput and 0 - 65535 on Linux */ This->effect.u.periodic.phase = (tsp->dwPhase / 36) * 65; /* dinput uses microseconds, Linux uses milliseconds */ if (tsp->dwPeriod <= 1000) This->effect.u.periodic.period = 1; else This->effect.u.periodic.period = tsp->dwPeriod / 1000; } else if (type == DIEFT_CONSTANTFORCE) { LPCDICONSTANTFORCE tsp; if (peff->cbTypeSpecificParams != sizeof(DICONSTANTFORCE)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams; This->effect.u.constant.level = (max(min(tsp->lMagnitude, 10000), -10000) / 10) * 32; } else if (type == DIEFT_RAMPFORCE) { LPCDIRAMPFORCE tsp; if (peff->cbTypeSpecificParams != sizeof(DIRAMPFORCE)) return DIERR_INVALIDPARAM; tsp = peff->lpvTypeSpecificParams; This->effect.u.ramp.start_level = (tsp->lStart / 10) * 32; This->effect.u.ramp.end_level = (tsp->lEnd / 10) * 32; } else if (type == DIEFT_CONDITION) { DICONDITION *tsp = peff->lpvTypeSpecificParams; struct ff_condition_effect *cond = This->effect.u.condition; int i, j, sources; double factor[2];
if (peff->cbTypeSpecificParams == sizeof(DICONDITION)) { /* One condition block. This needs to be rotated to direction, * and expanded to separate x and y conditions. Ensures 0 points right */ double angle = ff_effect_direction_to_rad(This->effect.direction + 0xc000); factor[0] = sin(angle); factor[1] = -cos(angle); sources = 1; } else if (peff->cbTypeSpecificParams == 2 * sizeof(DICONDITION)) { /* Direct parameter copy without changes */ factor[0] = factor[1] = 1; sources = 2; } else return DIERR_INVALIDPARAM;
for (i = j = 0; i < 2; ++i) { cond[i].center = (int)(factor[i] * (tsp[j].lOffset / 10) * 32); cond[i].right_coeff = (int)(factor[i] * (tsp[j].lPositiveCoefficient / 10) * 32); cond[i].left_coeff = (int)(factor[i] * (tsp[j].lNegativeCoefficient / 10) * 32); cond[i].right_saturation = (int)(factor[i] * (tsp[j].dwPositiveSaturation / 10) * 65); cond[i].left_saturation = (int)(factor[i] * (tsp[j].dwNegativeSaturation / 10) * 65); cond[i].deadband = (int)(factor[i] * (tsp[j].lDeadBand / 10) * 32); if (sources == 2) j++; } } else { FIXME("Custom force types are not supported\n"); return DIERR_INVALIDPARAM; } }
if (!(dwFlags & DIEP_NODOWNLOAD)) retval = LinuxInputEffectImpl_Download(iface); if (retval != DI_OK) return DI_DOWNLOADSKIPPED;
if (dwFlags & DIEP_NORESTART) TRACE("DIEP_NORESTART: not handled (we have no control of that).\n");
if (dwFlags & DIEP_START) retval = LinuxInputEffectImpl_Start(iface, 1, 0); if (retval != DI_OK) return retval; return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_Stop( LPDIRECTINPUTEFFECT iface){ struct input_event event; LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface);
TRACE("(this=%p)\n", This);
event.type = EV_FF; event.code = This->effect.id; event.value = 0; /* we don't care about the success or failure of this call */ write(*(This->fd), &event, sizeof(event));
return DI_OK;}
static HRESULT WINAPI LinuxInputEffectImpl_Unload( LPDIRECTINPUTEFFECT iface){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); TRACE("(this=%p)\n", This);
/* Erase the downloaded effect */ if (ioctl(*(This->fd), EVIOCRMFF, This->effect.id) == -1) return DIERR_INVALIDPARAM;
/* Mark the effect as deallocated */ This->effect.id = -1;
return DI_OK;}
static ULONG WINAPI LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface){ LinuxInputEffectImpl *This = impl_from_IDirectInputEffect(iface); ULONG ref = InterlockedDecrement(&(This->ref));
TRACE( "(%p) ref %d\n", This, ref );
if (ref == 0) { LinuxInputEffectImpl_Stop(iface); LinuxInputEffectImpl_Unload(iface); list_remove(This->entry); HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This->entry, effect_list_item, entry)); HeapFree(GetProcessHeap(), 0, This); } return ref;}
/****************************************************************************** * LinuxInputEffect */
DECLSPEC_HIDDEN HRESULT linuxinput_create_effect( int* fd, REFGUID rguid, struct list *parent_list_entry, LPDIRECTINPUTEFFECT* peff){ LinuxInputEffectImpl* newEffect = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LinuxInputEffectImpl)); DWORD type = typeFromGUID(rguid);
newEffect->IDirectInputEffect_iface.lpVtbl = &LinuxInputEffectVtbl; newEffect->ref = 1; newEffect->guid = *rguid; newEffect->fd = fd; newEffect->gain = 0xFFFF;
/* set the type. this cannot be changed over the effect's life. */ switch (type) { case DIEFT_PERIODIC: newEffect->effect.type = FF_PERIODIC; if (IsEqualGUID(rguid, &GUID_Sine)) { newEffect->effect.u.periodic.waveform = FF_SINE; } else if (IsEqualGUID(rguid, &GUID_Triangle)) { newEffect->effect.u.periodic.waveform = FF_TRIANGLE; } else if (IsEqualGUID(rguid, &GUID_Square)) { newEffect->effect.u.periodic.waveform = FF_SQUARE; } else if (IsEqualGUID(rguid, &GUID_SawtoothUp)) { newEffect->effect.u.periodic.waveform = FF_SAW_UP; } else if (IsEqualGUID(rguid, &GUID_SawtoothDown)) { newEffect->effect.u.periodic.waveform = FF_SAW_DOWN; } break; case DIEFT_CONSTANTFORCE: newEffect->effect.type = FF_CONSTANT; break; case DIEFT_RAMPFORCE: newEffect->effect.type = FF_RAMP; break; case DIEFT_CONDITION: if (IsEqualGUID(rguid, &GUID_Spring)) { newEffect->effect.type = FF_SPRING; } else if (IsEqualGUID(rguid, &GUID_Friction)) { newEffect->effect.type = FF_FRICTION; } else if (IsEqualGUID(rguid, &GUID_Inertia)) { newEffect->effect.type = FF_INERTIA; } else if (IsEqualGUID(rguid, &GUID_Damper)) { newEffect->effect.type = FF_DAMPER; } break; case DIEFT_CUSTOMFORCE: FIXME("Custom forces are not supported.\n"); HeapFree(GetProcessHeap(), 0, newEffect); return DIERR_INVALIDPARAM; default: FIXME("Unknown force type 0x%x.\n", type); HeapFree(GetProcessHeap(), 0, newEffect); return DIERR_INVALIDPARAM; }
/* mark as non-uploaded */ newEffect->effect.id = -1;
newEffect->entry = parent_list_entry;
*peff = &newEffect->IDirectInputEffect_iface;
TRACE("Creating linux input system effect (%p) with guid %s\n", *peff, _dump_dinput_GUID(rguid));
return DI_OK;}
DECLSPEC_HIDDEN HRESULT linuxinput_get_info_A( int fd, REFGUID rguid, LPDIEFFECTINFOA info){ DWORD type = typeFromGUID(rguid);
TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
if (!info) return E_POINTER;
if (info->dwSize != sizeof(DIEFFECTINFOA)) return DIERR_INVALIDPARAM;
info->guid = *rguid; info->dwEffType = type; /* the event device API does not support querying for all these things * therefore we assume that we have support for them * that's not as dangerous as it sounds, since drivers are allowed to * ignore parameters they claim to support anyway */ info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION | DIEFT_SATURATION | DIEFT_STARTDELAY;
/* again, assume we have support for everything */ info->dwStaticParams = DIEP_ALLPARAMS; info->dwDynamicParams = info->dwStaticParams;
/* yes, this is windows behavior (print the GUID_Name for name) */ strcpy(info->tszName, _dump_dinput_GUID(rguid));
return DI_OK;}
DECLSPEC_HIDDEN HRESULT linuxinput_get_info_W( int fd, REFGUID rguid, LPDIEFFECTINFOW info){ DWORD type = typeFromGUID(rguid);
TRACE("(%d, %s, %p) type=%d\n", fd, _dump_dinput_GUID(rguid), info, type);
if (!info) return E_POINTER;
if (info->dwSize != sizeof(DIEFFECTINFOW)) return DIERR_INVALIDPARAM;
info->guid = *rguid;
info->dwEffType = type; /* the event device API does not support querying for all these things * therefore we assume that we have support for them * that's not as dangerous as it sounds, since drivers are allowed to * ignore parameters they claim to support anyway */ info->dwEffType |= DIEFT_DEADBAND | DIEFT_FFATTACK | DIEFT_FFFADE | DIEFT_POSNEGCOEFFICIENTS | DIEFT_POSNEGSATURATION | DIEFT_SATURATION | DIEFT_STARTDELAY;
/* again, assume we have support for everything */ info->dwStaticParams = DIEP_ALLPARAMS; info->dwDynamicParams = info->dwStaticParams;
/* yes, this is windows behavior (print the GUID_Name for name) */ MultiByteToWideChar(CP_ACP, 0, _dump_dinput_GUID(rguid), -1, info->tszName, MAX_PATH);
return DI_OK;}
static const IDirectInputEffectVtbl LinuxInputEffectVtbl = { LinuxInputEffectImpl_QueryInterface, LinuxInputEffectImpl_AddRef, LinuxInputEffectImpl_Release, LinuxInputEffectImpl_Initialize, LinuxInputEffectImpl_GetEffectGuid, LinuxInputEffectImpl_GetParameters, LinuxInputEffectImpl_SetParameters, LinuxInputEffectImpl_Start, LinuxInputEffectImpl_Stop, LinuxInputEffectImpl_GetEffectStatus, LinuxInputEffectImpl_Download, LinuxInputEffectImpl_Unload, LinuxInputEffectImpl_Escape};
#endif /* HAVE_STRUCT_FF_EFFECT_DIRECTION */