[PATCH 1/6] quartz: Rename This to filter in the DirectSound Renderer Filter.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/quartz/dsoundrender.c | 242 ++++++++++++++++++-------------------
 1 file changed, 121 insertions(+), 121 deletions(-)

diff --git a/dlls/quartz/dsoundrender.c b/dlls/quartz/dsoundrender.c
index 10eed43422e..f31c0a4f40a 100644
--- a/dlls/quartz/dsoundrender.c
+++ b/dlls/quartz/dsoundrender.c
@@ -88,17 +88,17 @@ static struct dsound_render *impl_from_IAMDirectSound(IAMDirectSound *iface)
     return CONTAINING_RECORD(iface, struct dsound_render, IAMDirectSound_iface);
 }

-static REFERENCE_TIME time_from_pos(struct dsound_render *This, DWORD pos)
+static REFERENCE_TIME time_from_pos(struct dsound_render *filter, DWORD pos)
 {
-    WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
+    WAVEFORMATEX *wfx = (WAVEFORMATEX *)filter->sink.pin.mt.pbFormat;
     REFERENCE_TIME ret = 10000000;
     ret = ret * pos / wfx->nAvgBytesPerSec;
     return ret;
 }

-static DWORD pos_from_time(struct dsound_render *This, REFERENCE_TIME time)
+static DWORD pos_from_time(struct dsound_render *filter, REFERENCE_TIME time)
 {
-    WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
+    WAVEFORMATEX *wfx = (WAVEFORMATEX *)filter->sink.pin.mt.pbFormat;
     REFERENCE_TIME ret = time;
     ret *= wfx->nAvgBytesPerSec;
     ret /= 10000000;
@@ -106,56 +106,56 @@ static DWORD pos_from_time(struct dsound_render *This, REFERENCE_TIME time)
     return ret;
 }

-static void DSoundRender_UpdatePositions(struct dsound_render *This, DWORD *seqwritepos, DWORD *minwritepos)
+static void DSoundRender_UpdatePositions(struct dsound_render *filter, DWORD *seqwritepos, DWORD *minwritepos)
 {
-    WAVEFORMATEX *wfx = (WAVEFORMATEX *)This->sink.pin.mt.pbFormat;
+    WAVEFORMATEX *wfx = (WAVEFORMATEX *)filter->sink.pin.mt.pbFormat;
     BYTE *buf1, *buf2;
     DWORD size1, size2, playpos, writepos, old_writepos, old_playpos, adv;
-    BOOL writepos_set = This->writepos < This->buf_size;
+    BOOL writepos_set = filter->writepos < filter->buf_size;

/* Update position and zero */
-    old_writepos = This->writepos;
-    old_playpos = This->last_playpos;
+    old_writepos = filter->writepos;
+    old_playpos = filter->last_playpos;
     if (old_writepos <= old_playpos)
-        old_writepos += This->buf_size;
+        old_writepos += filter->buf_size;

-    IDirectSoundBuffer_GetCurrentPosition(This->dsbuffer, &playpos, &writepos);
+    IDirectSoundBuffer_GetCurrentPosition(filter->dsbuffer, &playpos, &writepos);
     if (old_playpos > playpos)
-        adv = This->buf_size + playpos - old_playpos;
+        adv = filter->buf_size + playpos - old_playpos;
     else
         adv = playpos - old_playpos;
-    This->last_playpos = playpos;
+    filter->last_playpos = playpos;
     if (adv) {
         TRACE("Moving from %lu to %lu: clearing %lu bytes.\n", old_playpos, playpos, adv);
-        IDirectSoundBuffer_Lock(This->dsbuffer, old_playpos, adv, (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
+        IDirectSoundBuffer_Lock(filter->dsbuffer, old_playpos, adv, (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
         memset(buf1, wfx->wBitsPerSample == 8 ? 128  : 0, size1);
         memset(buf2, wfx->wBitsPerSample == 8 ? 128  : 0, size2);
-        IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
+        IDirectSoundBuffer_Unlock(filter->dsbuffer, buf1, size1, buf2, size2);
     }
     *minwritepos = writepos;
     if (!writepos_set || old_writepos < writepos) {
         if (writepos_set) {
-            This->writepos = This->buf_size;
+            filter->writepos = filter->buf_size;
             FIXME("Underrun of data occurred!\n");
         }
         *seqwritepos = writepos;
     } else
-        *seqwritepos = This->writepos;
+        *seqwritepos = filter->writepos;
 }

-static HRESULT DSoundRender_GetWritePos(struct dsound_render *This,
+static HRESULT DSoundRender_GetWritePos(struct dsound_render *filter,
         DWORD *ret_writepos, REFERENCE_TIME write_at, DWORD *pfree, DWORD *skip)
 {
     DWORD writepos, min_writepos, playpos;
     REFERENCE_TIME max_lag = 50 * 10000;
     REFERENCE_TIME cur, writepos_t, delta_t;

-    DSoundRender_UpdatePositions(This, &writepos, &min_writepos);
-    playpos = This->last_playpos;
-    if (This->filter.clock)
+    DSoundRender_UpdatePositions(filter, &writepos, &min_writepos);
+    playpos = filter->last_playpos;
+    if (filter->filter.clock)
     {
-        IReferenceClock_GetTime(This->filter.clock, &cur);
-        cur -= This->stream_start;
+        IReferenceClock_GetTime(filter->filter.clock, &cur);
+        cur -= filter->stream_start;
     } else
         write_at = -1;

@@ -169,9 +169,9 @@ static HRESULT DSoundRender_GetWritePos(struct dsound_render *This,
     }

if (writepos >= playpos)
-        writepos_t = cur + time_from_pos(This, writepos - playpos);
+        writepos_t = cur + time_from_pos(filter, writepos - playpos);
     else
-        writepos_t = cur + time_from_pos(This, This->buf_size + writepos - playpos);
+        writepos_t = cur + time_from_pos(filter, filter->buf_size + writepos - playpos);

/* write_at: Starting time of sample */
     /* cur: current time of play position */
@@ -184,75 +184,75 @@ static HRESULT DSoundRender_GetWritePos(struct dsound_render *This,
         REFERENCE_TIME past, min_writepos_t;
         WARN("Delta too big %s/%s, overwriting old data or even skipping\n", debugstr_time(delta_t), debugstr_time(max_lag));
         if (min_writepos >= playpos)
-            min_writepos_t = cur + time_from_pos(This, min_writepos - playpos);
+            min_writepos_t = cur + time_from_pos(filter, min_writepos - playpos);
         else
-            min_writepos_t = cur + time_from_pos(This, This->buf_size - playpos + min_writepos);
+            min_writepos_t = cur + time_from_pos(filter, filter->buf_size - playpos + min_writepos);
         past = min_writepos_t - write_at;
         if (past >= 0) {
-            DWORD skipbytes = pos_from_time(This, past);
+            DWORD skipbytes = pos_from_time(filter, past);
             WARN("Skipping %lu bytes.\n", skipbytes);
             *skip = skipbytes;
             *ret_writepos = min_writepos;
         } else {
-            DWORD aheadbytes = pos_from_time(This, -past);
+            DWORD aheadbytes = pos_from_time(filter, -past);
             WARN("Advancing %lu bytes.\n", aheadbytes);
-            *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
+            *ret_writepos = (min_writepos + aheadbytes) % filter->buf_size;
         }
     } else /* delta_t > 0 */ {
         DWORD aheadbytes;
         WARN("Delta too big %s/%s, too far ahead\n", debugstr_time(delta_t), debugstr_time(max_lag));
-        aheadbytes = pos_from_time(This, delta_t);
+        aheadbytes = pos_from_time(filter, delta_t);
         WARN("Advancing %lu bytes.\n", aheadbytes);
         if (delta_t >= DSoundRenderer_Max_Fill)
             return S_FALSE;
-        *ret_writepos = (min_writepos + aheadbytes) % This->buf_size;
+        *ret_writepos = (min_writepos + aheadbytes) % filter->buf_size;
     }
 end:
     if (playpos >= *ret_writepos)
         *pfree = playpos - *ret_writepos;
     else
-        *pfree = This->buf_size + playpos - *ret_writepos;
-    if (time_from_pos(This, This->buf_size - *pfree) >= DSoundRenderer_Max_Fill) {
-        TRACE("Blocked: too full %s / %s\n", debugstr_time(time_from_pos(This, This->buf_size - *pfree)),
+        *pfree = filter->buf_size + playpos - *ret_writepos;
+    if (time_from_pos(filter, filter->buf_size - *pfree) >= DSoundRenderer_Max_Fill) {
+        TRACE("Blocked: too full %s / %s\n", debugstr_time(time_from_pos(filter, filter->buf_size - *pfree)),
                 debugstr_time(DSoundRenderer_Max_Fill));
         return S_FALSE;
     }
     return S_OK;
 }

-static HRESULT DSoundRender_HandleEndOfStream(struct dsound_render *This)
+static HRESULT DSoundRender_HandleEndOfStream(struct dsound_render *filter)
 {
-    while (This->filter.state == State_Running)
+    while (filter->filter.state == State_Running)
     {
         DWORD pos1, pos2;
-        DSoundRender_UpdatePositions(This, &pos1, &pos2);
+        DSoundRender_UpdatePositions(filter, &pos1, &pos2);
         if (pos1 == pos2)
             break;

-        WaitForSingleObject(This->flush_event, 10);
+        WaitForSingleObject(filter->flush_event, 10);
     }

return S_OK;
 }

-static HRESULT DSoundRender_SendSampleData(struct dsound_render *This,
+static HRESULT DSoundRender_SendSampleData(struct dsound_render *filter,
         REFERENCE_TIME tStart, REFERENCE_TIME tStop, const BYTE *data, DWORD size)
 {
     HRESULT hr;

-    while (size && This->filter.state != State_Stopped) {
+    while (size && filter->filter.state != State_Stopped) {
         DWORD writepos, skip = 0, free, size1, size2, ret;
         BYTE *buf1, *buf2;

-        if (This->filter.state == State_Running)
-            hr = DSoundRender_GetWritePos(This, &writepos, tStart, &free, &skip);
+        if (filter->filter.state == State_Running)
+            hr = DSoundRender_GetWritePos(filter, &writepos, tStart, &free, &skip);
         else
             hr = S_FALSE;

if (hr != S_OK) {
-            ret = WaitForSingleObject(This->flush_event, 10);
-            if (This->sink.flushing || This->filter.state == State_Stopped)
-                return This->filter.state == State_Paused ? S_OK : VFW_E_WRONG_STATE;
+            ret = WaitForSingleObject(filter->flush_event, 10);
+            if (filter->sink.flushing || filter->filter.state == State_Stopped)
+                return filter->filter.state == State_Paused ? S_OK : VFW_E_WRONG_STATE;
             if (ret != WAIT_TIMEOUT)
                 ERR("WaitForSingleObject() returned %ld.\n", ret);
             continue;
@@ -266,7 +266,7 @@ static HRESULT DSoundRender_SendSampleData(struct dsound_render *This,
         data += skip;
         size -= skip;

-        hr = IDirectSoundBuffer_Lock(This->dsbuffer, writepos, min(free, size), (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
+        hr = IDirectSoundBuffer_Lock(filter->dsbuffer, writepos, min(free, size), (void**)&buf1, &size1, (void**)&buf2, &size2, 0);
         if (hr != DS_OK) {
             ERR("Failed to lock sound buffer, hr %#lx.\n", hr);
             break;
@@ -274,23 +274,23 @@ static HRESULT DSoundRender_SendSampleData(struct dsound_render *This,
         memcpy(buf1, data, size1);
         if (size2)
             memcpy(buf2, data+size1, size2);
-        IDirectSoundBuffer_Unlock(This->dsbuffer, buf1, size1, buf2, size2);
-        This->writepos = (writepos + size1 + size2) % This->buf_size;
-        TRACE("Wrote %lu bytes at %lu, next at %lu - (%lu/%lu)\n", size1+size2, writepos, This->writepos, free, size);
+        IDirectSoundBuffer_Unlock(filter->dsbuffer, buf1, size1, buf2, size2);
+        filter->writepos = (writepos + size1 + size2) % filter->buf_size;
+        TRACE("Wrote %lu bytes at %lu, next at %lu - (%lu/%lu)\n", size1+size2, writepos, filter->writepos, free, size);
         data += size1 + size2;
         size -= size1 + size2;
     }
     return S_OK;
 }

-static HRESULT DSoundRender_PrepareReceive(struct dsound_render *This, IMediaSample *pSample)
+static HRESULT DSoundRender_PrepareReceive(struct dsound_render *filter, IMediaSample *pSample)
 {
     HRESULT hr;
     AM_MEDIA_TYPE *amt;

if (IMediaSample_GetMediaType(pSample, &amt) == S_OK)
     {
-        AM_MEDIA_TYPE *orig = &This->sink.pin.mt;
+        AM_MEDIA_TYPE *orig = &filter->sink.pin.mt;
         WAVEFORMATEX *origfmt = (WAVEFORMATEX *)orig->pbFormat;
         WAVEFORMATEX *newfmt = (WAVEFORMATEX *)amt->pbFormat;

@@ -305,7 +305,7 @@ static HRESULT DSoundRender_PrepareReceive(struct dsound_render *This, IMediaSam
         {
             if (origfmt->nSamplesPerSec != newfmt->nSamplesPerSec)
             {
-                hr = IDirectSoundBuffer_SetFrequency(This->dsbuffer,
+                hr = IDirectSoundBuffer_SetFrequency(filter->dsbuffer,
                                                      newfmt->nSamplesPerSec);
                 if (FAILED(hr))
                     return VFW_E_TYPE_NOT_ACCEPTED;
@@ -320,7 +320,7 @@ static HRESULT DSoundRender_PrepareReceive(struct dsound_render *This, IMediaSam
     return S_OK;
 }

-static HRESULT DSoundRender_DoRenderSample(struct dsound_render *This, IMediaSample *pSample)
+static HRESULT DSoundRender_DoRenderSample(struct dsound_render *filter, IMediaSample *pSample)
 {
     LPBYTE pbSrcStream = NULL;
     LONG cbSrcStream = 0;
@@ -347,7 +347,7 @@ static HRESULT DSoundRender_DoRenderSample(struct dsound_render *This, IMediaSam
     }

cbSrcStream = IMediaSample_GetActualDataLength(pSample);
-    return DSoundRender_SendSampleData(This, tStart, tStop, pbSrcStream, cbSrcStream);
+    return DSoundRender_SendSampleData(filter, tStart, tStop, pbSrcStream, cbSrcStream);
 }

static HRESULT WINAPI dsound_render_sink_Receive(struct strmbase_sink *iface, IMediaSample *sample)
@@ -397,42 +397,42 @@ static HRESULT dsound_render_sink_query_accept(struct strmbase_pin *iface, const

static HRESULT dsound_render_sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 {
-    struct dsound_render *This = impl_from_strmbase_pin(&iface->pin);
+    struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);
     const WAVEFORMATEX *format = (WAVEFORMATEX *)mt->pbFormat;
     HRESULT hr = S_OK;
     DSBUFFERDESC buf_desc;

-    This->buf_size = format->nAvgBytesPerSec;
+    filter->buf_size = format->nAvgBytesPerSec;

memset(&buf_desc,0,sizeof(DSBUFFERDESC));
     buf_desc.dwSize = sizeof(DSBUFFERDESC);
     buf_desc.dwFlags = DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN |
                        DSBCAPS_CTRLFREQUENCY | DSBCAPS_GLOBALFOCUS |
                        DSBCAPS_GETCURRENTPOSITION2;
-    buf_desc.dwBufferBytes = This->buf_size;
+    buf_desc.dwBufferBytes = filter->buf_size;
     buf_desc.lpwfxFormat = (WAVEFORMATEX *)format;
-    hr = IDirectSound8_CreateSoundBuffer(This->dsound, &buf_desc, &This->dsbuffer, NULL);
-    This->writepos = This->buf_size;
+    hr = IDirectSound8_CreateSoundBuffer(filter->dsound, &buf_desc, &filter->dsbuffer, NULL);
+    filter->writepos = filter->buf_size;
     if (FAILED(hr))
         ERR("Failed to create sound buffer, hr %#lx.\n", hr);

if (SUCCEEDED(hr))
     {
-        hr = IDirectSoundBuffer_SetVolume(This->dsbuffer, This->volume);
+        hr = IDirectSoundBuffer_SetVolume(filter->dsbuffer, filter->volume);
         if (FAILED(hr))
-            ERR("Failed to set volume to %ld, hr %#lx.\n", This->volume, hr);
+            ERR("Failed to set volume to %ld, hr %#lx.\n", filter->volume, hr);

-        hr = IDirectSoundBuffer_SetPan(This->dsbuffer, This->pan);
+        hr = IDirectSoundBuffer_SetPan(filter->dsbuffer, filter->pan);
         if (FAILED(hr))
-            ERR("Failed to set pan to %ld, hr %#lx.\n", This->pan, hr);
+            ERR("Failed to set pan to %ld, hr %#lx.\n", filter->pan, hr);
         hr = S_OK;
     }

if (FAILED(hr) && hr != VFW_E_ALREADY_CONNECTED)
     {
-        if (This->dsbuffer)
-            IDirectSoundBuffer_Release(This->dsbuffer);
-        This->dsbuffer = NULL;
+        if (filter->dsbuffer)
+            IDirectSoundBuffer_Release(filter->dsbuffer);
+        filter->dsbuffer = NULL;
     }

return hr;
@@ -440,13 +440,13 @@ static HRESULT dsound_render_sink_connect(struct strmbase_sink *iface, IPin *pee

static void dsound_render_sink_disconnect(struct strmbase_sink *iface)
 {
-    struct dsound_render *This = impl_from_strmbase_pin(&iface->pin);
+    struct dsound_render *filter = impl_from_strmbase_pin(&iface->pin);

TRACE("(%p)->()\n", iface);

-    if (This->dsbuffer)
-        IDirectSoundBuffer_Release(This->dsbuffer);
-    This->dsbuffer = NULL;
+    if (filter->dsbuffer)
+        IDirectSoundBuffer_Release(filter->dsbuffer);
+    filter->dsbuffer = NULL;
 }

static HRESULT dsound_render_sink_eos(struct strmbase_sink *iface)
@@ -668,27 +668,27 @@ static const struct strmbase_filter_ops filter_ops =
 static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface,
    					REFIID riid,
    					LPVOID*ppvObj) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
+    TRACE("(%p/%p)->(%s, %p)\n", filter, iface, debugstr_guid(riid), ppvObj);

-    return IUnknown_QueryInterface(This->filter.outer_unk, riid, ppvObj);
+    return IUnknown_QueryInterface(filter->filter.outer_unk, riid, ppvObj);
 }

static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("(%p/%p)->()\n", This, iface);
+    TRACE("(%p/%p)->()\n", filter, iface);

-    return IUnknown_AddRef(This->filter.outer_unk);
+    return IUnknown_AddRef(filter->filter.outer_unk);
 }

static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("(%p/%p)->()\n", This, iface);
+    TRACE("(%p/%p)->()\n", filter, iface);

-    return IUnknown_Release(This->filter.outer_unk);
+    return IUnknown_Release(filter->filter.outer_unk);
 }

HRESULT WINAPI basic_audio_GetTypeInfoCount(IBasicAudio *iface, UINT *count)
@@ -741,63 +741,63 @@ static HRESULT WINAPI basic_audio_Invoke(IBasicAudio *iface, DISPID id, REFIID i

static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface,
                                             LONG lVolume) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("filter %p, volume %ld.\n", This, lVolume);
+    TRACE("filter %p, volume %ld.\n", filter, lVolume);

if (lVolume > DSBVOLUME_MAX || lVolume < DSBVOLUME_MIN)
         return E_INVALIDARG;

-    if (This->dsbuffer) {
-        if (FAILED(IDirectSoundBuffer_SetVolume(This->dsbuffer, lVolume)))
+    if (filter->dsbuffer) {
+        if (FAILED(IDirectSoundBuffer_SetVolume(filter->dsbuffer, lVolume)))
             return E_FAIL;
     }

-    This->volume = lVolume;
+    filter->volume = lVolume;
     return S_OK;
 }

static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface,
                                             LONG *plVolume) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
+    TRACE("(%p/%p)->(%p)\n", filter, iface, plVolume);

if (!plVolume)
         return E_POINTER;

-    *plVolume = This->volume;
+    *plVolume = filter->volume;
     return S_OK;
 }

static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface,
                                              LONG lBalance) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("filter %p, balance %ld.\n", This, lBalance);
+    TRACE("filter %p, balance %ld.\n", filter, lBalance);

if (lBalance < DSBPAN_LEFT || lBalance > DSBPAN_RIGHT)
         return E_INVALIDARG;

-    if (This->dsbuffer) {
-        if (FAILED(IDirectSoundBuffer_SetPan(This->dsbuffer, lBalance)))
+    if (filter->dsbuffer) {
+        if (FAILED(IDirectSoundBuffer_SetPan(filter->dsbuffer, lBalance)))
             return E_FAIL;
     }

-    This->pan = lBalance;
+    filter->pan = lBalance;
     return S_OK;
 }

static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface,
                                              LONG *plBalance) {
-    struct dsound_render *This = impl_from_IBasicAudio(iface);
+    struct dsound_render *filter = impl_from_IBasicAudio(iface);

-    TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
+    TRACE("(%p/%p)->(%p)\n", filter, iface, plBalance);

if (!plBalance)
         return E_POINTER;

-    *plBalance = This->pan;
+    *plBalance = filter->pan;
     return S_OK;
 }

@@ -821,100 +821,100 @@ static HRESULT WINAPI AMDirectSound_QueryInterface(IAMDirectSound *iface,
    					REFIID riid,
    					LPVOID*ppvObj)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
+    TRACE("(%p/%p)->(%s, %p)\n", filter, iface, debugstr_guid(riid), ppvObj);

-    return IUnknown_QueryInterface(This->filter.outer_unk, riid, ppvObj);
+    return IUnknown_QueryInterface(filter->filter.outer_unk, riid, ppvObj);
 }

static ULONG WINAPI AMDirectSound_AddRef(IAMDirectSound *iface)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    TRACE("(%p/%p)->()\n", This, iface);
+    TRACE("(%p/%p)->()\n", filter, iface);

-    return IUnknown_AddRef(This->filter.outer_unk);
+    return IUnknown_AddRef(filter->filter.outer_unk);
 }

static ULONG WINAPI AMDirectSound_Release(IAMDirectSound *iface)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    TRACE("(%p/%p)->()\n", This, iface);
+    TRACE("(%p/%p)->()\n", filter, iface);

-    return IUnknown_Release(This->filter.outer_unk);
+    return IUnknown_Release(filter->filter.outer_unk);
 }

/*** IAMDirectSound methods ***/
 static HRESULT WINAPI AMDirectSound_GetDirectSoundInterface(IAMDirectSound *iface,  IDirectSound **ds)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, ds);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_GetPrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, buf);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_GetSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer **buf)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, buf);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_ReleaseDirectSoundInterface(IAMDirectSound *iface, IDirectSound *ds)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, ds);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, ds);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_ReleasePrimaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, buf);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_ReleaseSecondaryBufferInterface(IAMDirectSound *iface, IDirectSoundBuffer *buf)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p): stub\n", This, iface, buf);
+    FIXME("(%p/%p)->(%p): stub\n", filter, iface, buf);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_SetFocusWindow(IAMDirectSound *iface, HWND hwnd, BOOL bgaudible)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p,%d): stub\n", This, iface, hwnd, bgaudible);
+    FIXME("(%p/%p)->(%p,%d): stub\n", filter, iface, hwnd, bgaudible);

return E_NOTIMPL;
 }

static HRESULT WINAPI AMDirectSound_GetFocusWindow(IAMDirectSound *iface, HWND *hwnd, BOOL *bgaudible)
 {
-    struct dsound_render *This = impl_from_IAMDirectSound(iface);
+    struct dsound_render *filter = impl_from_IAMDirectSound(iface);

-    FIXME("(%p/%p)->(%p,%p): stub\n", This, iface, hwnd, bgaudible);
+    FIXME("(%p/%p)->(%p,%p): stub\n", filter, iface, hwnd, bgaudible);

return E_NOTIMPL;
 }