libs/strmbase/seeking.c

   1 /*
   2  * Filter Seeking and Control Interfaces
   3  *
   4  * Copyright 2003 Robert Shearman
   5  * Copyright 2010 Aric Stewart, CodeWeavers
   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 "strmbase_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  25
  26 static inline SourceSeeking *impl_from_IMediaSeeking(IMediaSeeking *iface)
  27 {
  28     return CONTAINING_RECORD(iface, SourceSeeking, IMediaSeeking_iface);
  29 }
  30
  31 HRESULT strmbase_seeking_init(SourceSeeking *pSeeking, const IMediaSeekingVtbl *Vtbl,
  32         SourceSeeking_ChangeStop fnChangeStop, SourceSeeking_ChangeStart fnChangeStart,
  33         SourceSeeking_ChangeRate fnChangeRate)
  34 {
  35     assert(fnChangeStop && fnChangeStart && fnChangeRate);
  36
  37     pSeeking->IMediaSeeking_iface.lpVtbl = Vtbl;
  38     pSeeking->refCount = 1;
  39     pSeeking->fnChangeRate = fnChangeRate;
  40     pSeeking->fnChangeStop = fnChangeStop;
  41     pSeeking->fnChangeStart = fnChangeStart;
  42     pSeeking->dwCapabilities = AM_SEEKING_CanSeekForwards |
  43         AM_SEEKING_CanSeekBackwards |
  44         AM_SEEKING_CanSeekAbsolute |
  45         AM_SEEKING_CanGetStopPos |
  46         AM_SEEKING_CanGetDuration;
  47     pSeeking->llCurrent = 0;
  48     pSeeking->llStop = ((ULONGLONG)0x80000000) << 32;
  49     pSeeking->llDuration = pSeeking->llStop;
  50     pSeeking->dRate = 1.0;
  51     pSeeking->timeformat = TIME_FORMAT_MEDIA_TIME;
  52     InitializeCriticalSection(&pSeeking->cs);
  53     pSeeking->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": SourceSeeking.cs");
  54     return S_OK;
  55 }
  56
  57 void strmbase_seeking_cleanup(SourceSeeking *seeking)
  58 {
  59     seeking->cs.DebugInfo->Spare[0] = 0;
  60     DeleteCriticalSection(&seeking->cs);
  61 }
  62
  63 HRESULT WINAPI SourceSeekingImpl_GetCapabilities(IMediaSeeking * iface, DWORD * pCapabilities)
  64 {
  65     SourceSeeking *This = impl_from_IMediaSeeking(iface);
  66
  67     TRACE("(%p)\n", pCapabilities);
  68
  69     *pCapabilities = This->dwCapabilities;
  70
  71     return S_OK;
  72 }
  73
  74 HRESULT WINAPI SourceSeekingImpl_CheckCapabilities(IMediaSeeking * iface, DWORD * pCapabilities)
  75 {
  76     SourceSeeking *This = impl_from_IMediaSeeking(iface);
  77     HRESULT hr;
  78     DWORD dwCommonCaps;
  79
  80     TRACE("(%p)\n", pCapabilities);
  81
  82     if (!pCapabilities)
  83         return E_POINTER;
  84
  85     dwCommonCaps = *pCapabilities & This->dwCapabilities;
  86
  87     if (!dwCommonCaps)
  88         hr = E_FAIL;
  89     else
  90         hr = (*pCapabilities == dwCommonCaps) ?  S_OK : S_FALSE;
  91     *pCapabilities = dwCommonCaps;
  92     return hr;
  93 }
  94
  95 HRESULT WINAPI SourceSeekingImpl_IsFormatSupported(IMediaSeeking * iface, const GUID * pFormat)
  96 {
  97     TRACE("(%s)\n", debugstr_guid(pFormat));
  98
  99     return (IsEqualIID(pFormat, &TIME_FORMAT_MEDIA_TIME) ? S_OK : S_FALSE);
 100 }
 101
 102 HRESULT WINAPI SourceSeekingImpl_QueryPreferredFormat(IMediaSeeking * iface, GUID * pFormat)
 103 {
 104     TRACE("(%s)\n", debugstr_guid(pFormat));
 105
 106     *pFormat = TIME_FORMAT_MEDIA_TIME;
 107     return S_OK;
 108 }
 109
 110 HRESULT WINAPI SourceSeekingImpl_GetTimeFormat(IMediaSeeking * iface, GUID * pFormat)
 111 {
 112     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 113     TRACE("(%s)\n", debugstr_guid(pFormat));
 114
 115     EnterCriticalSection(&This->cs);
 116     *pFormat = This->timeformat;
 117     LeaveCriticalSection(&This->cs);
 118
 119     return S_OK;
 120 }
 121
 122 HRESULT WINAPI SourceSeekingImpl_IsUsingTimeFormat(IMediaSeeking * iface, const GUID * pFormat)
 123 {
 124     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 125     HRESULT hr = S_OK;
 126
 127     TRACE("(%s)\n", debugstr_guid(pFormat));
 128
 129     EnterCriticalSection(&This->cs);
 130     if (!IsEqualIID(pFormat, &This->timeformat))
 131         hr = S_FALSE;
 132     LeaveCriticalSection(&This->cs);
 133
 134     return hr;
 135 }
 136
 137 HRESULT WINAPI SourceSeekingImpl_SetTimeFormat(IMediaSeeking * iface, const GUID * pFormat)
 138 {
 139     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 140     TRACE("%p %s\n", This, debugstr_guid(pFormat));
 141     return (IsEqualIID(pFormat, &TIME_FORMAT_MEDIA_TIME) ? S_OK : E_INVALIDARG);
 142 }
 143
 144
 145 HRESULT WINAPI SourceSeekingImpl_GetDuration(IMediaSeeking * iface, LONGLONG * pDuration)
 146 {
 147     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 148
 149     TRACE("(%p)\n", pDuration);
 150
 151     EnterCriticalSection(&This->cs);
 152     *pDuration = This->llDuration;
 153     LeaveCriticalSection(&This->cs);
 154
 155     return S_OK;
 156 }
 157
 158 HRESULT WINAPI SourceSeekingImpl_GetStopPosition(IMediaSeeking * iface, LONGLONG * pStop)
 159 {
 160     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 161
 162     TRACE("(%p)\n", pStop);
 163
 164     EnterCriticalSection(&This->cs);
 165     *pStop = This->llStop;
 166     LeaveCriticalSection(&This->cs);
 167
 168     return S_OK;
 169 }
 170
 171 /* FIXME: Make use of the info the filter should expose */
 172 HRESULT WINAPI SourceSeekingImpl_GetCurrentPosition(IMediaSeeking * iface, LONGLONG * pCurrent)
 173 {
 174     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 175
 176     TRACE("(%p)\n", pCurrent);
 177
 178     EnterCriticalSection(&This->cs);
 179     *pCurrent = This->llCurrent;
 180     LeaveCriticalSection(&This->cs);
 181
 182     return S_OK;
 183 }
 184
 185 HRESULT WINAPI SourceSeekingImpl_ConvertTimeFormat(IMediaSeeking * iface, LONGLONG * pTarget, const GUID * pTargetFormat, LONGLONG Source, const GUID * pSourceFormat)
 186 {
 187     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 188     if (!pTargetFormat)
 189         pTargetFormat = &This->timeformat;
 190     if (!pSourceFormat)
 191         pSourceFormat = &This->timeformat;
 192     if (IsEqualIID(pTargetFormat, &TIME_FORMAT_MEDIA_TIME) && IsEqualIID(pSourceFormat, &TIME_FORMAT_MEDIA_TIME))
 193     {
 194         *pTarget = Source;
 195         return S_OK;
 196     }
 197     /* FIXME: clear pTarget? */
 198     return E_INVALIDARG;
 199 }
 200
 201 static inline LONGLONG Adjust(LONGLONG value, const LONGLONG * pModifier, DWORD dwFlags)
 202 {
 203     switch (dwFlags & AM_SEEKING_PositioningBitsMask)
 204     {
 205     case AM_SEEKING_NoPositioning:
 206         return value;
 207     case AM_SEEKING_AbsolutePositioning:
 208         return *pModifier;
 209     case AM_SEEKING_RelativePositioning:
 210     case AM_SEEKING_IncrementalPositioning:
 211         return value + *pModifier;
 212     default:
 213         assert(FALSE);
 214         return 0;
 215     }
 216 }
 217
 218 HRESULT WINAPI SourceSeekingImpl_SetPositions(IMediaSeeking * iface, LONGLONG * pCurrent, DWORD dwCurrentFlags, LONGLONG * pStop, DWORD dwStopFlags)
 219 {
 220     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 221     BOOL bChangeCurrent = FALSE, bChangeStop = FALSE;
 222     LONGLONG llNewCurrent, llNewStop;
 223
 224     TRACE("iface %p, current %s, current_flags %#lx, stop %s, stop_flags %#lx.\n", iface,
 225             pCurrent ? debugstr_time(*pCurrent) : "<null>", dwCurrentFlags,
 226             pStop ? debugstr_time(*pStop): "<null>", dwStopFlags);
 227
 228     EnterCriticalSection(&This->cs);
 229
 230     llNewCurrent = Adjust(This->llCurrent, pCurrent, dwCurrentFlags);
 231     llNewStop = Adjust(This->llStop, pStop, dwStopFlags);
 232
 233     if (pCurrent)
 234         bChangeCurrent = TRUE;
 235     if (llNewStop != This->llStop)
 236         bChangeStop = TRUE;
 237
 238     TRACE("Seeking from %s to %s.\n", debugstr_time(This->llCurrent), debugstr_time(llNewCurrent));
 239
 240     This->llCurrent = llNewCurrent;
 241     This->llStop = llNewStop;
 242
 243     if (pCurrent && (dwCurrentFlags & AM_SEEKING_ReturnTime))
 244         *pCurrent = llNewCurrent;
 245     if (pStop && (dwStopFlags & AM_SEEKING_ReturnTime))
 246         *pStop = llNewStop;
 247     LeaveCriticalSection(&This->cs);
 248
 249     if (bChangeCurrent)
 250         This->fnChangeStart(iface);
 251     if (bChangeStop)
 252         This->fnChangeStop(iface);
 253
 254     return S_OK;
 255 }
 256
 257 HRESULT WINAPI SourceSeekingImpl_GetPositions(IMediaSeeking * iface, LONGLONG * pCurrent, LONGLONG * pStop)
 258 {
 259     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 260
 261     TRACE("(%p, %p)\n", pCurrent, pStop);
 262
 263     EnterCriticalSection(&This->cs);
 264     IMediaSeeking_GetCurrentPosition(iface, pCurrent);
 265     IMediaSeeking_GetStopPosition(iface, pStop);
 266     LeaveCriticalSection(&This->cs);
 267
 268     return S_OK;
 269 }
 270
 271 HRESULT WINAPI SourceSeekingImpl_GetAvailable(IMediaSeeking * iface, LONGLONG * pEarliest, LONGLONG * pLatest)
 272 {
 273     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 274
 275     TRACE("(%p, %p)\n", pEarliest, pLatest);
 276
 277     EnterCriticalSection(&This->cs);
 278     *pEarliest = 0;
 279     *pLatest = This->llDuration;
 280     LeaveCriticalSection(&This->cs);
 281
 282     return S_OK;
 283 }
 284
 285 HRESULT WINAPI SourceSeekingImpl_SetRate(IMediaSeeking * iface, double dRate)
 286 {
 287     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 288     BOOL bChangeRate = (dRate != This->dRate);
 289     HRESULT hr = S_OK;
 290
 291     TRACE("(%e)\n", dRate);
 292
 293     if (dRate > 100 || dRate < .001)
 294     {
 295         FIXME("Excessive rate %e, ignoring\n", dRate);
 296         return VFW_E_UNSUPPORTED_AUDIO;
 297     }
 298
 299     EnterCriticalSection(&This->cs);
 300     This->dRate = dRate;
 301     if (bChangeRate)
 302         hr = This->fnChangeRate(iface);
 303     LeaveCriticalSection(&This->cs);
 304
 305     return hr;
 306 }
 307
 308 HRESULT WINAPI SourceSeekingImpl_GetRate(IMediaSeeking * iface, double * dRate)
 309 {
 310     SourceSeeking *This = impl_from_IMediaSeeking(iface);
 311
 312     TRACE("(%p)\n", dRate);
 313
 314     EnterCriticalSection(&This->cs);
 315     /* Forward? */
 316     *dRate = This->dRate;
 317     LeaveCriticalSection(&This->cs);
 318
 319     return S_OK;
 320 }
 321
 322 HRESULT WINAPI SourceSeekingImpl_GetPreroll(IMediaSeeking * iface, LONGLONG * pPreroll)
 323 {
 324     TRACE("(%p)\n", pPreroll);
 325
 326     *pPreroll = 0;
 327     return S_OK;
 328 }