system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-01 08:13:18 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/dsdmo/main.c
Alistair Leslie-Hughes 39889f19c3 dsdmo: Add Compressor FX Support.
2022-08-17 16:43:22 +02:00

1244 lines
38 KiB
C
Raw Blame History

/*
* Copyright 2019 Alistair Leslie-Hughes
*
* 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
*/
#define COBJMACROS
#include "dmo.h"
#include "mmreg.h"
#include "mmsystem.h"
#include "uuids.h"
#include "initguid.h"
#include "medparam.h"
#include "dsound.h"
#include "rpcproxy.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(dsdmo);
struct effect
{
IMediaObject IMediaObject_iface;
IMediaObjectInPlace IMediaObjectInPlace_iface;
IMediaParams IMediaParams_iface;
IMediaParamInfo IMediaParamInfo_iface;
IUnknown IUnknown_inner;
IUnknown *outer_unk;
LONG refcount;
CRITICAL_SECTION cs;
WAVEFORMATEX format;
const struct effect_ops *ops;
};
struct effect_ops
{
void *(*query_interface)(struct effect *effect, REFIID iid);
void (*destroy)(struct effect *effect);
};
static struct effect *impl_from_IUnknown(IUnknown *iface)
{
return CONTAINING_RECORD(iface, struct effect, IUnknown_inner);
}
static HRESULT WINAPI effect_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
{
struct effect *effect = impl_from_IUnknown(iface);
TRACE("effect %p, iid %s, out %p.\n", effect, debugstr_guid(iid), out);
if (IsEqualGUID(iid, &IID_IUnknown))
*out = iface;
else if (IsEqualGUID(iid, &IID_IMediaObject))
*out = &effect->IMediaObject_iface;
else if (IsEqualGUID(iid, &IID_IMediaObjectInPlace))
*out = &effect->IMediaObjectInPlace_iface;
else if (IsEqualGUID(iid, &IID_IMediaParams))
*out = &effect->IMediaParams_iface;
else if (IsEqualGUID(iid, &IID_IMediaParamInfo))
*out = &effect->IMediaParamInfo_iface;
else if (!(*out = effect->ops->query_interface(effect, iid)))
{
WARN("%s not implemented; returning E_NOINTERFACE.\n", debugstr_guid(iid));
return E_NOINTERFACE;
}
IUnknown_AddRef((IUnknown *)*out);
return S_OK;
}
static ULONG WINAPI effect_inner_AddRef(IUnknown *iface)
{
struct effect *effect = impl_from_IUnknown(iface);
ULONG refcount = InterlockedIncrement(&effect->refcount);
TRACE("%p increasing refcount to %lu.\n", effect, refcount);
return refcount;
}
static ULONG WINAPI effect_inner_Release(IUnknown *iface)
{
struct effect *effect = impl_from_IUnknown(iface);
ULONG refcount = InterlockedDecrement(&effect->refcount);
TRACE("%p decreasing refcount to %lu.\n", effect, refcount);
if (!refcount)
{
effect->cs.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&effect->cs);
effect->ops->destroy(effect);
}
return refcount;
}
static const IUnknownVtbl effect_inner_vtbl =
{
effect_inner_QueryInterface,
effect_inner_AddRef,
effect_inner_Release,
};
static struct effect *impl_from_IMediaObject(IMediaObject *iface)
{
return CONTAINING_RECORD(iface, struct effect, IMediaObject_iface);
}
static HRESULT WINAPI effect_QueryInterface(IMediaObject *iface, REFIID iid, void **out)
{
struct effect *effect = impl_from_IMediaObject(iface);
return IUnknown_QueryInterface(effect->outer_unk, iid, out);
}
static ULONG WINAPI effect_AddRef(IMediaObject *iface)
{
struct effect *effect = impl_from_IMediaObject(iface);
return IUnknown_AddRef(effect->outer_unk);
}
static ULONG WINAPI effect_Release(IMediaObject *iface)
{
struct effect *effect = impl_from_IMediaObject(iface);
return IUnknown_Release(effect->outer_unk);
}
static HRESULT WINAPI effect_GetStreamCount(IMediaObject *iface, DWORD *input, DWORD *output)
{
FIXME("iface %p, input %p, output %p, stub!\n", iface, input, output);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetInputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
{
FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetOutputStreamInfo(IMediaObject *iface, DWORD index, DWORD *flags)
{
FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetInputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
{
FIXME("iface %p, index %lu, type_index %lu, type %p, stub!\n", iface, index, type_index, type);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetOutputType(IMediaObject *iface, DWORD index, DWORD type_index, DMO_MEDIA_TYPE *type)
{
FIXME("iface %p, index %lu, type_index %lu, type %p, stub!\n", iface, index, type_index, type);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_SetInputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
{
struct effect *effect = impl_from_IMediaObject(iface);
const WAVEFORMATEX *format;
TRACE("iface %p, index %lu, type %p, flags %#lx.\n", iface, index, type, flags);
if (flags & DMO_SET_TYPEF_CLEAR)
{
EnterCriticalSection(&effect->cs);
memset(&effect->format, 0, sizeof(effect->format));
LeaveCriticalSection(&effect->cs);
return S_OK;
}
if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
return DMO_E_TYPE_NOT_ACCEPTED;
if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
&& !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
return DMO_E_TYPE_NOT_ACCEPTED;
if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
return DMO_E_TYPE_NOT_ACCEPTED;
format = (const WAVEFORMATEX *)type->pbFormat;
if (format->wFormatTag == WAVE_FORMAT_PCM)
{
if (format->wBitsPerSample != 8 && format->wBitsPerSample != 16)
{
WARN("Rejecting %u-bit integer PCM.\n", format->wBitsPerSample);
return DMO_E_TYPE_NOT_ACCEPTED;
}
}
else if (format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
{
if (format->wBitsPerSample != 32)
{
WARN("Rejecting %u-bit float PCM.\n", format->wBitsPerSample);
return DMO_E_TYPE_NOT_ACCEPTED;
}
}
else
{
WARN("Rejecting tag %#x.\n", format->wFormatTag);
return DMO_E_TYPE_NOT_ACCEPTED;
}
if (format->nChannels != 1 && format->nChannels != 2)
{
WARN("Rejecting %u channels.\n", format->nChannels);
return DMO_E_TYPE_NOT_ACCEPTED;
}
EnterCriticalSection(&effect->cs);
effect->format = *format;
LeaveCriticalSection(&effect->cs);
return S_OK;
}
static HRESULT WINAPI effect_SetOutputType(IMediaObject *iface, DWORD index, const DMO_MEDIA_TYPE *type, DWORD flags)
{
struct effect *effect = impl_from_IMediaObject(iface);
HRESULT hr;
TRACE("iface %p, index %lu, type %p, flags %#lx.\n", iface, index, type, flags);
if (flags & DMO_SET_TYPEF_CLEAR)
return S_OK;
if (!IsEqualGUID(&type->majortype, &MEDIATYPE_Audio))
return DMO_E_TYPE_NOT_ACCEPTED;
if (!IsEqualGUID(&type->subtype, &MEDIASUBTYPE_PCM)
&& !IsEqualGUID(&type->subtype, &MEDIASUBTYPE_IEEE_FLOAT))
return DMO_E_TYPE_NOT_ACCEPTED;
if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
return DMO_E_TYPE_NOT_ACCEPTED;
EnterCriticalSection(&effect->cs);
hr = memcmp(type->pbFormat, &effect->format, sizeof(WAVEFORMATEX)) ? DMO_E_TYPE_NOT_ACCEPTED : S_OK;
LeaveCriticalSection(&effect->cs);
return hr;
}
static HRESULT WINAPI effect_GetInputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
{
FIXME("iface %p, index %lu, type %p, stub!\n", iface, index, type);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetOutputCurrentType(IMediaObject *iface, DWORD index, DMO_MEDIA_TYPE *type)
{
FIXME("iface %p, index %lu, type %p, stub!\n", iface, index, type);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetInputSizeInfo(IMediaObject *iface, DWORD index,
DWORD *size, DWORD *lookahead, DWORD *alignment)
{
FIXME("iface %p, index %lu, size %p, lookahead %p, alignment %p, stub!\n", iface, index, size, lookahead, alignment);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetOutputSizeInfo(IMediaObject *iface, DWORD index, DWORD *size, DWORD *alignment)
{
FIXME("iface %p, index %lu, size %p, alignment %p, stub!\n", iface, index, size, alignment);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME *latency)
{
FIXME("iface %p, index %lu, latency %p, stub!\n", iface, index, latency);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_SetInputMaxLatency(IMediaObject *iface, DWORD index, REFERENCE_TIME latency)
{
FIXME("iface %p, index %lu, latency %s, stub!\n", iface, index, wine_dbgstr_longlong(latency));
return E_NOTIMPL;
}
static HRESULT WINAPI effect_Flush(IMediaObject *iface)
{
FIXME("iface %p, stub!\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_Discontinuity(IMediaObject *iface, DWORD index)
{
FIXME("iface %p, index %lu, stub!\n", iface, index);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_AllocateStreamingResources(IMediaObject *iface)
{
FIXME("iface %p, stub!\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_FreeStreamingResources(IMediaObject *iface)
{
FIXME("iface %p, stub!\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_GetInputStatus(IMediaObject *iface, DWORD index, DWORD *flags)
{
FIXME("iface %p, index %lu, flags %p, stub!\n", iface, index, flags);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_ProcessInput(IMediaObject *iface, DWORD index,
IMediaBuffer *buffer, DWORD flags, REFERENCE_TIME timestamp, REFERENCE_TIME timelength)
{
FIXME("iface %p, index %lu, buffer %p, flags %#lx, timestamp %s, timelength %s, stub!\n",
iface, index, buffer, flags, wine_dbgstr_longlong(timestamp), wine_dbgstr_longlong(timelength));
return E_NOTIMPL;
}
static HRESULT WINAPI effect_ProcessOutput(IMediaObject *iface, DWORD flags,
DWORD count, DMO_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
{
FIXME("iface %p, flags %#lx, count %lu, buffers %p, status %p, stub!\n", iface, flags, count, buffers, status);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_Lock(IMediaObject *iface, LONG lock)
{
FIXME("iface %p, lock %ld, stub!\n", iface, lock);
return E_NOTIMPL;
}
static const IMediaObjectVtbl effect_vtbl =
{
effect_QueryInterface,
effect_AddRef,
effect_Release,
effect_GetStreamCount,
effect_GetInputStreamInfo,
effect_GetOutputStreamInfo,
effect_GetInputType,
effect_GetOutputType,
effect_SetInputType,
effect_SetOutputType,
effect_GetInputCurrentType,
effect_GetOutputCurrentType,
effect_GetInputSizeInfo,
effect_GetOutputSizeInfo,
effect_GetInputMaxLatency,
effect_SetInputMaxLatency,
effect_Flush,
effect_Discontinuity,
effect_AllocateStreamingResources,
effect_FreeStreamingResources,
effect_GetInputStatus,
effect_ProcessInput,
effect_ProcessOutput,
effect_Lock,
};
static struct effect *impl_from_IMediaObjectInPlace(IMediaObjectInPlace *iface)
{
return CONTAINING_RECORD(iface, struct effect, IMediaObjectInPlace_iface);
}
static HRESULT WINAPI effect_inplace_QueryInterface(IMediaObjectInPlace *iface, REFIID iid, void **out)
{
struct effect *effect = impl_from_IMediaObjectInPlace(iface);
return IUnknown_QueryInterface(effect->outer_unk, iid, out);
}
static ULONG WINAPI effect_inplace_AddRef(IMediaObjectInPlace *iface)
{
struct effect *effect = impl_from_IMediaObjectInPlace(iface);
return IUnknown_AddRef(effect->outer_unk);
}
static ULONG WINAPI effect_inplace_Release(IMediaObjectInPlace *iface)
{
struct effect *effect = impl_from_IMediaObjectInPlace(iface);
return IUnknown_Release(effect->outer_unk);
}
static HRESULT WINAPI effect_inplace_Process(IMediaObjectInPlace *iface, ULONG size,
BYTE *data, REFERENCE_TIME start, DWORD flags)
{
FIXME("iface %p, size %lu, data %p, start %s, flags %#lx, stub!\n",
iface, size, data, wine_dbgstr_longlong(start), flags);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_inplace_Clone(IMediaObjectInPlace *iface, IMediaObjectInPlace **out)
{
FIXME("iface %p, out %p, stub!\n", iface, out);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_inplace_GetLatency(IMediaObjectInPlace *iface, REFERENCE_TIME *latency)
{
FIXME("iface %p, latency %p, stub!\n", iface, latency);
return E_NOTIMPL;
}
static const IMediaObjectInPlaceVtbl effect_inplace_vtbl =
{
effect_inplace_QueryInterface,
effect_inplace_AddRef,
effect_inplace_Release,
effect_inplace_Process,
effect_inplace_Clone,
effect_inplace_GetLatency,
};
static struct effect *impl_from_IMediaParams(IMediaParams *iface)
{
return CONTAINING_RECORD(iface, struct effect, IMediaParams_iface);
}
static HRESULT WINAPI effect_media_params_QueryInterface(IMediaParams *iface, REFIID iid, void **out)
{
struct effect *effect = impl_from_IMediaParams(iface);
return IUnknown_QueryInterface(effect->outer_unk, iid, out);
}
static ULONG WINAPI effect_media_params_AddRef(IMediaParams *iface)
{
struct effect *effect = impl_from_IMediaParams(iface);
return IUnknown_AddRef(effect->outer_unk);
}
static ULONG WINAPI effect_media_params_Release(IMediaParams *iface)
{
struct effect *effect = impl_from_IMediaParams(iface);
return IUnknown_Release(effect->outer_unk);
}
static HRESULT WINAPI effect_media_params_GetParam(IMediaParams *iface, DWORD index, MP_DATA *data)
{
FIXME("iface %p, index %lu, data %p, stub!\n", iface, index, data);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_params_SetParam(IMediaParams *iface, DWORD index, MP_DATA data)
{
FIXME("iface %p, index %lu, data %f, stub!\n", iface, index, data);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_params_AddEnvelope(IMediaParams *iface, DWORD index, DWORD count,
MP_ENVELOPE_SEGMENT *segments)
{
FIXME("iface %p, index %lu, count %lu, segments %p, stub!\n", iface, index, count, segments);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_params_FlushEnvelope(IMediaParams *iface, DWORD index,
REFERENCE_TIME start, REFERENCE_TIME end)
{
FIXME("iface %p, index %lu, start %s, end %s, stub!\n", iface, index,
wine_dbgstr_longlong(start), wine_dbgstr_longlong(end));
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_params_SetTimeFormat(IMediaParams *iface, GUID guid,
MP_TIMEDATA time_data)
{
FIXME("iface %p, guid %s, time_data %lx, stub!\n", iface, wine_dbgstr_guid(&guid), time_data);
return E_NOTIMPL;
}
static const IMediaParamsVtbl effect_media_params_vtbl =
{
effect_media_params_QueryInterface,
effect_media_params_AddRef,
effect_media_params_Release,
effect_media_params_GetParam,
effect_media_params_SetParam,
effect_media_params_AddEnvelope,
effect_media_params_FlushEnvelope,
effect_media_params_SetTimeFormat,
};
static struct effect *impl_from_IMediaParamInfo(IMediaParamInfo *iface)
{
return CONTAINING_RECORD(iface, struct effect, IMediaParamInfo_iface);
}
static HRESULT WINAPI effect_media_param_info_QueryInterface(IMediaParamInfo *iface, REFIID iid, void **out)
{
struct effect *effect = impl_from_IMediaParamInfo(iface);
return IUnknown_QueryInterface(effect->outer_unk, iid, out);
}
static ULONG WINAPI effect_media_param_info_AddRef(IMediaParamInfo *iface)
{
struct effect *effect = impl_from_IMediaParamInfo(iface);
return IUnknown_AddRef(effect->outer_unk);
}
static ULONG WINAPI effect_media_param_info_Release(IMediaParamInfo *iface)
{
struct effect *effect = impl_from_IMediaParamInfo(iface);
return IUnknown_Release(effect->outer_unk);
}
static HRESULT WINAPI effect_media_param_info_GetParamCount(IMediaParamInfo *iface, DWORD *count)
{
FIXME("iface %p, count %p, stub!\n", iface, count);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_param_info_GetParamInfo(IMediaParamInfo *iface, DWORD index, MP_PARAMINFO *info)
{
FIXME("iface %p, index %lu, info %p, stub!\n", iface, index, info);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_param_info_GetParamText(IMediaParamInfo *iface, DWORD index, WCHAR **text)
{
FIXME("iface %p, index %lu, text %p, stub!\n", iface, index, text);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_param_info_GetNumTimeFormats(IMediaParamInfo *iface, DWORD *count)
{
FIXME("iface %p, count %p, stub!\n", iface, count);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_param_info_GetSupportedTimeFormat(IMediaParamInfo *iface, DWORD index, GUID *guid)
{
FIXME("iface %p, index %lu, guid %p, stub!\n", iface, index, guid);
return E_NOTIMPL;
}
static HRESULT WINAPI effect_media_param_info_GetCurrentTimeFormat(IMediaParamInfo *iface, GUID *guid, MP_TIMEDATA *time_data)
{
FIXME("iface %p, guid %p, time_data %p, stub!\n", iface, guid, time_data);
return E_NOTIMPL;
}
static const IMediaParamInfoVtbl effect_media_param_info_vtbl =
{
effect_media_param_info_QueryInterface,
effect_media_param_info_AddRef,
effect_media_param_info_Release,
effect_media_param_info_GetParamCount,
effect_media_param_info_GetParamInfo,
effect_media_param_info_GetParamText,
effect_media_param_info_GetNumTimeFormats,
effect_media_param_info_GetSupportedTimeFormat,
effect_media_param_info_GetCurrentTimeFormat,
};
static void effect_init(struct effect *effect, IUnknown *outer, const struct effect_ops *ops)
{
effect->outer_unk = outer ? outer : &effect->IUnknown_inner;
effect->refcount = 1;
effect->IUnknown_inner.lpVtbl = &effect_inner_vtbl;
effect->IMediaObject_iface.lpVtbl = &effect_vtbl;
effect->IMediaObjectInPlace_iface.lpVtbl = &effect_inplace_vtbl;
effect->IMediaParams_iface.lpVtbl = &effect_media_params_vtbl;
effect->IMediaParamInfo_iface.lpVtbl = &effect_media_param_info_vtbl;
InitializeCriticalSection(&effect->cs);
effect->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": effect.cs");
effect->ops = ops;
}
struct eq
{
struct effect effect;
IDirectSoundFXParamEq IDirectSoundFXParamEq_iface;
DSFXParamEq params;
};
static struct eq *impl_from_IDirectSoundFXParamEq(IDirectSoundFXParamEq *iface)
{
return CONTAINING_RECORD(iface, struct eq, IDirectSoundFXParamEq_iface);
}
static HRESULT WINAPI eq_params_QueryInterface(IDirectSoundFXParamEq *iface, REFIID iid, void **out)
{
struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
}
static ULONG WINAPI eq_params_AddRef(IDirectSoundFXParamEq *iface)
{
struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
return IUnknown_AddRef(effect->effect.outer_unk);
}
static ULONG WINAPI eq_params_Release(IDirectSoundFXParamEq *iface)
{
struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
return IUnknown_Release(effect->effect.outer_unk);
}
static HRESULT WINAPI eq_params_SetAllParameters(IDirectSoundFXParamEq *iface, const DSFXParamEq *params)
{
struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
TRACE("effect %p, params %p.\n", effect, params);
EnterCriticalSection(&effect->effect.cs);
effect->params = *params;
LeaveCriticalSection(&effect->effect.cs);
return S_OK;
}
static HRESULT WINAPI eq_params_GetAllParameters(IDirectSoundFXParamEq *iface, DSFXParamEq *params)
{
struct eq *effect = impl_from_IDirectSoundFXParamEq(iface);
TRACE("effect %p, params %p.\n", effect, params);
EnterCriticalSection(&effect->effect.cs);
*params = effect->params;
LeaveCriticalSection(&effect->effect.cs);
return S_OK;
}
static const IDirectSoundFXParamEqVtbl eq_params_vtbl =
{
eq_params_QueryInterface,
eq_params_AddRef,
eq_params_Release,
eq_params_SetAllParameters,
eq_params_GetAllParameters,
};
static struct eq *impl_eq_from_effect(struct effect *iface)
{
return CONTAINING_RECORD(iface, struct eq, effect);
}
static void *eq_query_interface(struct effect *iface, REFIID iid)
{
struct eq *effect = impl_eq_from_effect(iface);
if (IsEqualGUID(iid, &IID_IDirectSoundFXParamEq))
return &effect->IDirectSoundFXParamEq_iface;
return NULL;
}
static void eq_destroy(struct effect *iface)
{
struct eq *effect = impl_eq_from_effect(iface);
free(effect);
}
static const struct effect_ops eq_ops =
{
.destroy = eq_destroy,
.query_interface = eq_query_interface,
};
static HRESULT eq_create(IUnknown *outer, IUnknown **out)
{
struct eq *object;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
effect_init(&object->effect, outer, &eq_ops);
object->IDirectSoundFXParamEq_iface.lpVtbl = &eq_params_vtbl;
object->params.fCenter = 8000.0f;
object->params.fBandwidth = 12.0f;
object->params.fGain = 0.0f;
TRACE("Created equalizer effect %p.\n", object);
*out = &object->effect.IUnknown_inner;
return S_OK;
}
struct reverb
{
struct effect effect;
IDirectSoundFXI3DL2Reverb IDirectSoundFXI3DL2Reverb_iface;
DSFXI3DL2Reverb params;
};
static struct reverb *impl_from_IDirectSoundFXI3DL2Reverb(IDirectSoundFXI3DL2Reverb *iface)
{
return CONTAINING_RECORD(iface, struct reverb, IDirectSoundFXI3DL2Reverb_iface);
}
static HRESULT WINAPI reverb_params_QueryInterface(IDirectSoundFXI3DL2Reverb *iface, REFIID iid, void **out)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
}
static ULONG WINAPI reverb_params_AddRef(IDirectSoundFXI3DL2Reverb *iface)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
return IUnknown_AddRef(effect->effect.outer_unk);
}
static ULONG WINAPI reverb_params_Release(IDirectSoundFXI3DL2Reverb *iface)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
return IUnknown_Release(effect->effect.outer_unk);
}
static HRESULT WINAPI reverb_params_SetAllParameters(IDirectSoundFXI3DL2Reverb *iface, const DSFXI3DL2Reverb *params)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
TRACE("effect %p, params %p.\n", effect, params);
EnterCriticalSection(&effect->effect.cs);
effect->params = *params;
LeaveCriticalSection(&effect->effect.cs);
return S_OK;
}
static HRESULT WINAPI reverb_params_GetAllParameters(IDirectSoundFXI3DL2Reverb *iface, DSFXI3DL2Reverb *params)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
TRACE("effect %p, params %p.\n", effect, params);
EnterCriticalSection(&effect->effect.cs);
*params = effect->params;
LeaveCriticalSection(&effect->effect.cs);
return S_OK;
}
static HRESULT WINAPI reverb_params_SetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD preset)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
FIXME("effect %p, preset %lu, stub!\n", effect, preset);
return E_NOTIMPL;
}
static HRESULT WINAPI reverb_params_GetPreset(IDirectSoundFXI3DL2Reverb *iface, DWORD *preset)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
FIXME("effect %p, preset %p, stub!\n", effect, preset);
return E_NOTIMPL;
}
static HRESULT WINAPI reverb_params_SetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG quality)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
FIXME("effect %p, quality %lu, stub!\n", effect, quality);
return E_NOTIMPL;
}
static HRESULT WINAPI reverb_params_GetQuality(IDirectSoundFXI3DL2Reverb *iface, LONG *quality)
{
struct reverb *effect = impl_from_IDirectSoundFXI3DL2Reverb(iface);
FIXME("effect %p, quality %p, stub!\n", effect, quality);
return E_NOTIMPL;
}
static const IDirectSoundFXI3DL2ReverbVtbl reverb_params_vtbl =
{
reverb_params_QueryInterface,
reverb_params_AddRef,
reverb_params_Release,
reverb_params_SetAllParameters,
reverb_params_GetAllParameters,
reverb_params_SetPreset,
reverb_params_GetPreset,
reverb_params_SetQuality,
reverb_params_GetQuality,
};
static struct reverb *impl_reverb_from_effect(struct effect *iface)
{
return CONTAINING_RECORD(iface, struct reverb, effect);
}
static void *reverb_query_interface(struct effect *iface, REFIID iid)
{
struct reverb *effect = impl_reverb_from_effect(iface);
if (IsEqualGUID(iid, &IID_IDirectSoundFXI3DL2Reverb))
return &effect->IDirectSoundFXI3DL2Reverb_iface;
return NULL;
}
static void reverb_destroy(struct effect *iface)
{
struct reverb *effect = impl_reverb_from_effect(iface);
free(effect);
}
static const struct effect_ops reverb_ops =
{
.destroy = reverb_destroy,
.query_interface = reverb_query_interface,
};
static HRESULT reverb_create(IUnknown *outer, IUnknown **out)
{
struct reverb *object;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
effect_init(&object->effect, outer, &reverb_ops);
object->IDirectSoundFXI3DL2Reverb_iface.lpVtbl = &reverb_params_vtbl;
object->params.lRoom = DSFX_I3DL2REVERB_ROOM_DEFAULT;
object->params.lRoomHF = DSFX_I3DL2REVERB_ROOMHF_DEFAULT;
object->params.flRoomRolloffFactor = DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_DEFAULT;
object->params.flDecayTime = DSFX_I3DL2REVERB_DECAYTIME_DEFAULT;
object->params.flDecayHFRatio = DSFX_I3DL2REVERB_DECAYHFRATIO_DEFAULT;
object->params.lReflections = DSFX_I3DL2REVERB_REFLECTIONS_DEFAULT;
object->params.flReflectionsDelay = DSFX_I3DL2REVERB_REFLECTIONSDELAY_DEFAULT;
object->params.lReverb = DSFX_I3DL2REVERB_REVERB_DEFAULT;
object->params.flReverbDelay = DSFX_I3DL2REVERB_REVERBDELAY_DEFAULT;
object->params.flDiffusion = DSFX_I3DL2REVERB_DIFFUSION_DEFAULT;
object->params.flDensity = DSFX_I3DL2REVERB_DENSITY_DEFAULT;
object->params.flHFReference = DSFX_I3DL2REVERB_HFREFERENCE_DEFAULT;
TRACE("Created I3DL2 reverb effect %p.\n", object);
*out = &object->effect.IUnknown_inner;
return S_OK;
}
struct waves_reverb
{
struct effect effect;
IDirectSoundFXWavesReverb IDirectSoundFXWavesReverb_iface;
};
static struct waves_reverb *impl_from_IDirectSoundFXWavesReverb(IDirectSoundFXWavesReverb *iface)
{
return CONTAINING_RECORD(iface, struct waves_reverb, IDirectSoundFXWavesReverb_iface);
}
static HRESULT WINAPI waves_reverb_params_QueryInterface(IDirectSoundFXWavesReverb *iface, REFIID iid, void **out)
{
struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
}
static ULONG WINAPI waves_reverb_params_AddRef(IDirectSoundFXWavesReverb *iface)
{
struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
return IUnknown_AddRef(effect->effect.outer_unk);
}
static ULONG WINAPI waves_reverb_params_Release(IDirectSoundFXWavesReverb *iface)
{
struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
return IUnknown_Release(effect->effect.outer_unk);
}
static HRESULT WINAPI waves_reverb_params_SetAllParameters(IDirectSoundFXWavesReverb *iface, const DSFXWavesReverb *params)
{
struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
FIXME("effect %p, params %p, stub!\n", effect, params);
return E_NOTIMPL;
}
static HRESULT WINAPI waves_reverb_params_GetAllParameters(IDirectSoundFXWavesReverb *iface, DSFXWavesReverb *params)
{
struct waves_reverb *effect = impl_from_IDirectSoundFXWavesReverb(iface);
FIXME("effect %p, params %p, stub!\n", effect, params);
return E_NOTIMPL;
}
static const IDirectSoundFXWavesReverbVtbl waves_reverb_params_vtbl =
{
waves_reverb_params_QueryInterface,
waves_reverb_params_AddRef,
waves_reverb_params_Release,
waves_reverb_params_SetAllParameters,
waves_reverb_params_GetAllParameters,
};
static struct waves_reverb *impl_waves_reverb_from_effect(struct effect *iface)
{
return CONTAINING_RECORD(iface, struct waves_reverb, effect);
}
static void *waves_reverb_query_interface(struct effect *iface, REFIID iid)
{
struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
if (IsEqualGUID(iid, &IID_IDirectSoundFXWavesReverb))
return &effect->IDirectSoundFXWavesReverb_iface;
return NULL;
}
static void waves_reverb_destroy(struct effect *iface)
{
struct waves_reverb *effect = impl_waves_reverb_from_effect(iface);
free(effect);
}
static const struct effect_ops waves_reverb_ops =
{
.destroy = waves_reverb_destroy,
.query_interface = waves_reverb_query_interface,
};
static HRESULT waves_reverb_create(IUnknown *outer, IUnknown **out)
{
struct waves_reverb *object;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
effect_init(&object->effect, outer, &waves_reverb_ops);
object->IDirectSoundFXWavesReverb_iface.lpVtbl = &waves_reverb_params_vtbl;
TRACE("Created waves reverb effect %p.\n", object);
*out = &object->effect.IUnknown_inner;
return S_OK;
}
struct dmo_echofx
{
struct effect effect;
IDirectSoundFXEcho IDirectSoundFXEcho_iface;
};
static inline struct dmo_echofx *impl_from_IDirectSoundFXEcho(IDirectSoundFXEcho *iface)
{
return CONTAINING_RECORD(iface, struct dmo_echofx, IDirectSoundFXEcho_iface);
}
static HRESULT WINAPI echofx_QueryInterface(IDirectSoundFXEcho *iface, REFIID iid, void **out)
{
struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
}
static ULONG WINAPI echofx_AddRef(IDirectSoundFXEcho *iface)
{
struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
return IUnknown_AddRef(effect->effect.outer_unk);
}
static ULONG WINAPI echofx_Release(IDirectSoundFXEcho *iface)
{
struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
return IUnknown_Release(effect->effect.outer_unk);
}
static HRESULT WINAPI echofx_SetAllParameters(IDirectSoundFXEcho *iface, const DSFXEcho *echo)
{
struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
FIXME("(%p) %p\n", effect, echo);
return E_NOTIMPL;
}
static HRESULT WINAPI echofx_GetAllParameters(IDirectSoundFXEcho *iface, DSFXEcho *echo)
{
struct dmo_echofx *effect = impl_from_IDirectSoundFXEcho(iface);
FIXME("(%p) %p\n", effect, echo);
return E_NOTIMPL;
}
static const struct IDirectSoundFXEchoVtbl echofx_vtbl =
{
echofx_QueryInterface,
echofx_AddRef,
echofx_Release,
echofx_SetAllParameters,
echofx_GetAllParameters
};
static struct dmo_echofx *impl_echo_from_effect(struct effect *iface)
{
return CONTAINING_RECORD(iface, struct dmo_echofx, effect);
}
static void *echo_query_interface(struct effect *iface, REFIID iid)
{
struct dmo_echofx *effect = impl_echo_from_effect(iface);
if (IsEqualGUID(iid, &IID_IDirectSoundFXEcho))
return &effect->IDirectSoundFXEcho_iface;
return NULL;
}
static void echo_destroy(struct effect *iface)
{
struct dmo_echofx *effect = impl_echo_from_effect(iface);
free(effect);
}
static const struct effect_ops echo_ops =
{
.destroy = echo_destroy,
.query_interface = echo_query_interface,
};
static HRESULT echo_create(IUnknown *outer, IUnknown **out)
{
struct dmo_echofx *object;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
effect_init(&object->effect, outer, &echo_ops);
object->IDirectSoundFXEcho_iface.lpVtbl = &echofx_vtbl;
TRACE("Created echo effect %p.\n", object);
*out = &object->effect.IUnknown_inner;
return S_OK;
}
struct dmo_compressorfx
{
struct effect effect;
IDirectSoundFXCompressor IDirectSoundFXCompressor_iface;
};
static inline struct dmo_compressorfx *impl_from_IDirectSoundFXCompressor(IDirectSoundFXCompressor *iface)
{
return CONTAINING_RECORD(iface, struct dmo_compressorfx, IDirectSoundFXCompressor_iface);
}
static HRESULT WINAPI compressorfx_QueryInterface(IDirectSoundFXCompressor *iface, REFIID iid, void **out)
{
struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
return IUnknown_QueryInterface(effect->effect.outer_unk, iid, out);
}
static ULONG WINAPI compressorfx_AddRef(IDirectSoundFXCompressor *iface)
{
struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
return IUnknown_AddRef(effect->effect.outer_unk);
}
static ULONG WINAPI compressorfx_Release(IDirectSoundFXCompressor *iface)
{
struct dmo_compressorfx *effect = impl_from_IDirectSoundFXCompressor(iface);
return IUnknown_Release(effect->effect.outer_unk);
}
static HRESULT WINAPI compressorfx_SetAllParameters(IDirectSoundFXCompressor *iface, const DSFXCompressor *compressor)
{
struct dmo_compressorfx *This = impl_from_IDirectSoundFXCompressor(iface);
FIXME("(%p) %p\n", This, compressor);
return E_NOTIMPL;
}
static HRESULT WINAPI compressorfx_GetAllParameters(IDirectSoundFXCompressor *iface, DSFXCompressor *compressor)
{
struct dmo_compressorfx *This = impl_from_IDirectSoundFXCompressor(iface);
FIXME("(%p) %p\n", This, compressor);
return E_NOTIMPL;
}
static const struct IDirectSoundFXCompressorVtbl compressor_vtbl =
{
compressorfx_QueryInterface,
compressorfx_AddRef,
compressorfx_Release,
compressorfx_SetAllParameters,
compressorfx_GetAllParameters
};
static struct dmo_compressorfx *impl_compressor_from_effect(struct effect *iface)
{
return CONTAINING_RECORD(iface, struct dmo_compressorfx, effect);
}
static void *compressor_query_interface(struct effect *iface, REFIID iid)
{
struct dmo_compressorfx *effect = impl_compressor_from_effect(iface);
if (IsEqualGUID(iid, &IID_IDirectSoundFXCompressor))
return &effect->IDirectSoundFXCompressor_iface;
return NULL;
}
static void compressor_destroy(struct effect *iface)
{
struct dmo_compressorfx *effect = impl_compressor_from_effect(iface);
free(effect);
}
static const struct effect_ops compressor_ops =
{
.destroy = compressor_destroy,
.query_interface = compressor_query_interface,
};
static HRESULT compressor_create(IUnknown *outer, IUnknown **out)
{
struct dmo_compressorfx *object;
if (!(object = calloc(1, sizeof(*object))))
return E_OUTOFMEMORY;
effect_init(&object->effect, outer, &compressor_ops);
object->IDirectSoundFXCompressor_iface.lpVtbl = &compressor_vtbl;
TRACE("Created compressor effect %p.\n", object);
*out = &object->effect.IUnknown_inner;
return S_OK;
}
struct class_factory
{
IClassFactory IClassFactory_iface;
HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
};
static struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
{
return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
}
static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
{
TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
{
IClassFactory_AddRef(iface);
*out = iface;
return S_OK;
}
*out = NULL;
WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(iid));
return E_NOINTERFACE;
}
static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
{
return 2;
}
static ULONG WINAPI class_factory_Release(IClassFactory *iface)
{
return 1;
}
static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface,
IUnknown *outer, REFIID iid, void **out)
{
struct class_factory *factory = impl_from_IClassFactory(iface);
IUnknown *unk;
HRESULT hr;
TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
*out = NULL;
if (outer && !IsEqualGUID(iid, &IID_IUnknown))
return E_NOINTERFACE;
if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
{
hr = IUnknown_QueryInterface(unk, iid, out);
IUnknown_Release(unk);
}
return hr;
}
static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
{
FIXME("lock %d, stub!\n", lock);
return S_OK;
}
static const IClassFactoryVtbl class_factory_vtbl =
{
class_factory_QueryInterface,
class_factory_AddRef,
class_factory_Release,
class_factory_CreateInstance,
class_factory_LockServer,
};
static struct
{
const GUID *clsid;
struct class_factory factory;
}
class_factories[] =
{
{&GUID_DSFX_STANDARD_I3DL2REVERB, {{&class_factory_vtbl}, reverb_create}},
{&GUID_DSFX_STANDARD_PARAMEQ, {{&class_factory_vtbl}, eq_create}},
{&GUID_DSFX_WAVES_REVERB, {{&class_factory_vtbl}, waves_reverb_create}},
{&GUID_DSFX_STANDARD_ECHO, {{&class_factory_vtbl}, echo_create}},
{&GUID_DSFX_STANDARD_COMPRESSOR, {{&class_factory_vtbl}, compressor_create}},
};
HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
{
unsigned int i;
TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
for (i = 0; i < ARRAY_SIZE(class_factories); ++i)
{
if (IsEqualGUID(clsid, class_factories[i].clsid))
return IClassFactory_QueryInterface(&class_factories[i].factory.IClassFactory_iface, iid, out);
}
FIXME("%s not available, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
return CLASS_E_CLASSNOTAVAILABLE;
}
Reference in a new issue View git blame Copy permalink