dlls/quartz/filesource.c

   1 /*
   2  * File Source Filter
   3  *
   4  * Copyright 2003 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23
  24 #include "quartz_private.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/unicode.h"
  28 #include "pin.h"
  29 #include "uuids.h"
  30 #include "vfwmsgs.h"
  31 #include "winbase.h"
  32 #include "winreg.h"
  33 #include "shlwapi.h"
  34 #include <assert.h>
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  37
  38 static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
  39
  40 typedef struct AsyncReader
  41 {
  42     BaseFilter filter;
  43     const IFileSourceFilterVtbl * lpVtblFSF;
  44
  45     DWORD lastpinchange;
  46
  47     IPin * pOutputPin;
  48     LPOLESTR pszFileName;
  49     AM_MEDIA_TYPE * pmt;
  50 } AsyncReader;
  51
  52 static const IBaseFilterVtbl AsyncReader_Vtbl;
  53 static const IFileSourceFilterVtbl FileSource_Vtbl;
  54 static const IAsyncReaderVtbl FileAsyncReader_Vtbl;
  55
  56 static HRESULT FileAsyncReader_Construct(HANDLE hFile, IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec, IPin ** ppPin);
  57
  58 static inline AsyncReader *impl_from_IFileSourceFilter( IFileSourceFilter *iface )
  59 {
  60     return (AsyncReader *)((char*)iface - FIELD_OFFSET(AsyncReader, lpVtblFSF));
  61 }
  62
  63 static WCHAR const mediatype_name[11] = {
  64     'M', 'e', 'd', 'i', 'a', ' ', 'T', 'y', 'p', 'e', 0 };
  65 static WCHAR const subtype_name[8] = {
  66     'S', 'u', 'b', 't', 'y', 'p', 'e', 0 };
  67
  68 static HRESULT process_extensions(HKEY hkeyExtensions, LPCOLESTR pszFileName, GUID * majorType, GUID * minorType)
  69 {
  70     WCHAR *extension;
  71     LONG l;
  72     HKEY hsub;
  73     WCHAR keying[39];
  74     DWORD size;
  75
  76     if (!pszFileName)
  77         return E_POINTER;
  78
  79     /* Get the part of the name that matters */
  80     extension = PathFindExtensionW(pszFileName);
  81     if (*extension != '.')
  82         return E_FAIL;
  83
  84     l = RegOpenKeyExW(hkeyExtensions, extension, 0, KEY_READ, &hsub);
  85     if (l)
  86         return E_FAIL;
  87
  88     size = sizeof(keying);
  89     l = RegQueryValueExW(hsub, mediatype_name, NULL, NULL, (LPBYTE)keying, &size);
  90     if (!l)
  91         CLSIDFromString(keying, majorType);
  92
  93     size = sizeof(keying);
  94     if (!l)
  95         l = RegQueryValueExW(hsub, subtype_name, NULL, NULL, (LPBYTE)keying, &size);
  96
  97     if (!l)
  98         CLSIDFromString(keying, minorType);
  99
 100     RegCloseKey(hsub);
 101
 102     if (!l)
 103         return S_OK;
 104     return E_FAIL;
 105 }
 106
 107 static unsigned char byte_from_hex_char(WCHAR wHex)
 108 {
 109     switch (tolowerW(wHex))
 110     {
 111     case '0':
 112     case '1':
 113     case '2':
 114     case '3':
 115     case '4':
 116     case '5':
 117     case '6':
 118     case '7':
 119     case '8':
 120     case '9':
 121         return (wHex - '0') & 0xf;
 122     case 'a':
 123     case 'b':
 124     case 'c':
 125     case 'd':
 126     case 'e':
 127     case 'f':
 128         return (wHex - 'a' + 10) & 0xf;
 129     default:
 130         return 0;
 131     }
 132 }
 133
 134 static HRESULT process_pattern_string(LPCWSTR wszPatternString, IAsyncReader * pReader)
 135 {
 136     ULONG ulOffset;
 137     ULONG ulBytes;
 138     BYTE * pbMask;
 139     BYTE * pbValue;
 140     BYTE * pbFile;
 141     HRESULT hr = S_OK;
 142     ULONG strpos;
 143
 144     TRACE("\t\tPattern string: %s\n", debugstr_w(wszPatternString));
 145
 146     /* format: "offset, bytestocompare, mask, value" */
 147
 148     ulOffset = strtolW(wszPatternString, NULL, 10);
 149
 150     if (!(wszPatternString = strchrW(wszPatternString, ',')))
 151         return E_INVALIDARG;
 152
 153     wszPatternString++; /* skip ',' */
 154
 155     ulBytes = strtolW(wszPatternString, NULL, 10);
 156
 157     pbMask = HeapAlloc(GetProcessHeap(), 0, ulBytes);
 158     pbValue = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulBytes);
 159     pbFile = HeapAlloc(GetProcessHeap(), 0, ulBytes);
 160
 161     /* default mask is match everything */
 162     memset(pbMask, 0xFF, ulBytes);
 163
 164     if (!(wszPatternString = strchrW(wszPatternString, ',')))
 165         hr = E_INVALIDARG;
 166
 167     if (hr == S_OK)
 168     {
 169         wszPatternString++; /* skip ',' */
 170         while (!isxdigitW(*wszPatternString) && (*wszPatternString != ',')) wszPatternString++;
 171
 172         for (strpos = 0; isxdigitW(*wszPatternString) && (strpos/2 < ulBytes); wszPatternString++, strpos++)
 173         {
 174             if ((strpos % 2) == 1) /* odd numbered position */
 175                 pbMask[strpos / 2] |= byte_from_hex_char(*wszPatternString);
 176             else
 177                 pbMask[strpos / 2] = byte_from_hex_char(*wszPatternString) << 4;
 178         }
 179
 180         if (!(wszPatternString = strchrW(wszPatternString, ',')))
 181             hr = E_INVALIDARG;
 182
 183         wszPatternString++; /* skip ',' */
 184     }
 185
 186     if (hr == S_OK)
 187     {
 188         for ( ; !isxdigitW(*wszPatternString) && (*wszPatternString != ','); wszPatternString++)
 189             ;
 190
 191         for (strpos = 0; isxdigitW(*wszPatternString) && (strpos/2 < ulBytes); wszPatternString++, strpos++)
 192         {
 193             if ((strpos % 2) == 1) /* odd numbered position */
 194                 pbValue[strpos / 2] |= byte_from_hex_char(*wszPatternString);
 195             else
 196                 pbValue[strpos / 2] = byte_from_hex_char(*wszPatternString) << 4;
 197         }
 198     }
 199
 200     if (hr == S_OK)
 201         hr = IAsyncReader_SyncRead(pReader, ulOffset, ulBytes, pbFile);
 202
 203     if (hr == S_OK)
 204     {
 205         ULONG i;
 206         for (i = 0; i < ulBytes; i++)
 207             if ((pbFile[i] & pbMask[i]) != pbValue[i])
 208             {
 209                 hr = S_FALSE;
 210                 break;
 211             }
 212     }
 213
 214     HeapFree(GetProcessHeap(), 0, pbMask);
 215     HeapFree(GetProcessHeap(), 0, pbValue);
 216     HeapFree(GetProcessHeap(), 0, pbFile);
 217
 218     /* if we encountered no errors with this string, and there is a following tuple, then we
 219      * have to match that as well to succeed */
 220     if ((hr == S_OK) && (wszPatternString = strchrW(wszPatternString, ',')))
 221         return process_pattern_string(wszPatternString + 1, pReader);
 222     else
 223         return hr;
 224 }
 225
 226 static HRESULT GetClassMediaFile(IAsyncReader * pReader, LPCOLESTR pszFileName, GUID * majorType, GUID * minorType)
 227 {
 228     HKEY hkeyMediaType = NULL;
 229     LONG lRet;
 230     HRESULT hr = S_OK;
 231     BOOL bFound = FALSE;
 232     static const WCHAR wszMediaType[] = {'M','e','d','i','a',' ','T','y','p','e',0};
 233
 234     TRACE("(%p, %s, %p, %p)\n", pReader, debugstr_w(pszFileName), majorType, minorType);
 235
 236     *majorType = GUID_NULL;
 237     *minorType = GUID_NULL;
 238
 239     lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszMediaType, 0, KEY_READ, &hkeyMediaType);
 240     hr = HRESULT_FROM_WIN32(lRet);
 241
 242     if (SUCCEEDED(hr))
 243     {
 244         DWORD indexMajor;
 245
 246         for (indexMajor = 0; !bFound; indexMajor++)
 247         {
 248             HKEY hkeyMajor;
 249             WCHAR wszMajorKeyName[CHARS_IN_GUID];
 250             DWORD dwKeyNameLength = sizeof(wszMajorKeyName) / sizeof(wszMajorKeyName[0]);
 251             static const WCHAR wszExtensions[] = {'E','x','t','e','n','s','i','o','n','s',0};
 252
 253             if (RegEnumKeyExW(hkeyMediaType, indexMajor, wszMajorKeyName, &dwKeyNameLength, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 254                 break;
 255             if (RegOpenKeyExW(hkeyMediaType, wszMajorKeyName, 0, KEY_READ, &hkeyMajor) != ERROR_SUCCESS)
 256                 break;
 257             TRACE("%s\n", debugstr_w(wszMajorKeyName));
 258             if (!strcmpW(wszExtensions, wszMajorKeyName))
 259             {
 260                 if (process_extensions(hkeyMajor, pszFileName, majorType, minorType) == S_OK)
 261                     bFound = TRUE;
 262             }
 263             else
 264             {
 265                 DWORD indexMinor;
 266
 267                 for (indexMinor = 0; !bFound; indexMinor++)
 268                 {
 269                     HKEY hkeyMinor;
 270                     WCHAR wszMinorKeyName[CHARS_IN_GUID];
 271                     DWORD dwMinorKeyNameLen = sizeof(wszMinorKeyName) / sizeof(wszMinorKeyName[0]);
 272                     DWORD maxValueLen;
 273                     DWORD indexValue;
 274
 275                     if (RegEnumKeyExW(hkeyMajor, indexMinor, wszMinorKeyName, &dwMinorKeyNameLen, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
 276                         break;
 277
 278                     if (RegOpenKeyExW(hkeyMajor, wszMinorKeyName, 0, KEY_READ, &hkeyMinor) != ERROR_SUCCESS)
 279                         break;
 280
 281                     TRACE("\t%s\n", debugstr_w(wszMinorKeyName));
 282
 283                     if (RegQueryInfoKeyW(hkeyMinor, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &maxValueLen, NULL, NULL) != ERROR_SUCCESS)
 284                         break;
 285
 286                     for (indexValue = 0; !bFound; indexValue++)
 287                     {
 288                         DWORD dwType;
 289                         WCHAR wszValueName[14]; /* longest name we should encounter will be "Source Filter" */
 290                         LPWSTR wszPatternString = HeapAlloc(GetProcessHeap(), 0, maxValueLen);
 291                         DWORD dwValueNameLen = sizeof(wszValueName) / sizeof(wszValueName[0]); /* remember this is in chars */
 292                         DWORD dwDataLen = maxValueLen; /* remember this is in bytes */
 293                         static const WCHAR wszSourceFilter[] = {'S','o','u','r','c','e',' ','F','i','l','t','e','r',0};
 294                         LONG temp;
 295
 296                         if ((temp = RegEnumValueW(hkeyMinor, indexValue, wszValueName, &dwValueNameLen, NULL, &dwType, (LPBYTE)wszPatternString, &dwDataLen)) != ERROR_SUCCESS)
 297                         {
 298                             HeapFree(GetProcessHeap(), 0, wszPatternString);
 299                             break;
 300                         }
 301
 302                         /* if it is not the source filter value */
 303                         if (strcmpW(wszValueName, wszSourceFilter))
 304                         {
 305                             if (process_pattern_string(wszPatternString, pReader) == S_OK)
 306                             {
 307                                 if (SUCCEEDED(CLSIDFromString(wszMajorKeyName, majorType)) &&
 308                                     SUCCEEDED(CLSIDFromString(wszMinorKeyName, minorType)))
 309                                     bFound = TRUE;
 310                             }
 311                         }
 312                         HeapFree(GetProcessHeap(), 0, wszPatternString);
 313                     }
 314                     CloseHandle(hkeyMinor);
 315                 }
 316             }
 317             CloseHandle(hkeyMajor);
 318         }
 319     }
 320     CloseHandle(hkeyMediaType);
 321
 322     if (SUCCEEDED(hr) && !bFound)
 323     {
 324         ERR("Media class not found\n");
 325         hr = E_FAIL;
 326     }
 327     else if (bFound)
 328         TRACE("Found file's class: major = %s, subtype = %s\n", qzdebugstr_guid(majorType), qzdebugstr_guid(minorType));
 329
 330     return hr;
 331 }
 332
 333 HRESULT AsyncReader_create(IUnknown * pUnkOuter, LPVOID * ppv)
 334 {
 335     AsyncReader *pAsyncRead;
 336
 337     if( pUnkOuter )
 338         return CLASS_E_NOAGGREGATION;
 339
 340     pAsyncRead = CoTaskMemAlloc(sizeof(AsyncReader));
 341
 342     if (!pAsyncRead)
 343         return E_OUTOFMEMORY;
 344
 345     BaseFilter_Init(&pAsyncRead->filter, &AsyncReader_Vtbl, &CLSID_AsyncReader, (DWORD_PTR)(__FILE__ ": AsyncReader.csFilter"));
 346
 347     pAsyncRead->lpVtblFSF = &FileSource_Vtbl;
 348     pAsyncRead->pOutputPin = NULL;
 349     pAsyncRead->lastpinchange = GetTickCount();
 350
 351     pAsyncRead->pszFileName = NULL;
 352     pAsyncRead->pmt = NULL;
 353
 354     *ppv = pAsyncRead;
 355
 356     TRACE("-- created at %p\n", pAsyncRead);
 357
 358     return S_OK;
 359 }
 360
 361 /** IUnknown methods **/
 362
 363 static HRESULT WINAPI AsyncReader_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 364 {
 365     AsyncReader *This = (AsyncReader *)iface;
 366
 367     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 368
 369     *ppv = NULL;
 370
 371     if (IsEqualIID(riid, &IID_IUnknown))
 372         *ppv = This;
 373     else if (IsEqualIID(riid, &IID_IPersist))
 374         *ppv = This;
 375     else if (IsEqualIID(riid, &IID_IMediaFilter))
 376         *ppv = This;
 377     else if (IsEqualIID(riid, &IID_IBaseFilter))
 378         *ppv = This;
 379     else if (IsEqualIID(riid, &IID_IFileSourceFilter))
 380         *ppv = &This->lpVtblFSF;
 381
 382     if (*ppv)
 383     {
 384         IUnknown_AddRef((IUnknown *)(*ppv));
 385         return S_OK;
 386     }
 387
 388     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IMediaSeeking) &&
 389         !IsEqualIID(riid, &IID_IVideoWindow) && !IsEqualIID(riid, &IID_IBasicAudio))
 390         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 391
 392     return E_NOINTERFACE;
 393 }
 394
 395 static ULONG WINAPI AsyncReader_Release(IBaseFilter * iface)
 396 {
 397     AsyncReader *This = (AsyncReader *)iface;
 398     ULONG refCount = BaseFilterImpl_Release(iface);
 399
 400     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 401
 402     if (!refCount)
 403     {
 404         if (This->pOutputPin)
 405         {
 406             IPin *pConnectedTo;
 407             if(SUCCEEDED(IPin_ConnectedTo(This->pOutputPin, &pConnectedTo)))
 408             {
 409                 IPin_Disconnect(pConnectedTo);
 410                 IPin_Release(pConnectedTo);
 411             }
 412             IPin_Disconnect(This->pOutputPin);
 413             IPin_Release(This->pOutputPin);
 414         }
 415         CoTaskMemFree(This->pszFileName);
 416         if (This->pmt)
 417             FreeMediaType(This->pmt);
 418         CoTaskMemFree(This);
 419         return 0;
 420     }
 421     else
 422         return refCount;
 423 }
 424
 425 /** IMediaFilter methods **/
 426
 427 static HRESULT WINAPI AsyncReader_Stop(IBaseFilter * iface)
 428 {
 429     AsyncReader *This = (AsyncReader *)iface;
 430
 431     TRACE("()\n");
 432
 433     This->filter.state = State_Stopped;
 434
 435     return S_OK;
 436 }
 437
 438 static HRESULT WINAPI AsyncReader_Pause(IBaseFilter * iface)
 439 {
 440     AsyncReader *This = (AsyncReader *)iface;
 441
 442     TRACE("()\n");
 443
 444     This->filter.state = State_Paused;
 445
 446     return S_OK;
 447 }
 448
 449 static HRESULT WINAPI AsyncReader_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 450 {
 451     AsyncReader *This = (AsyncReader *)iface;
 452
 453     TRACE("(%x%08x)\n", (ULONG)(tStart >> 32), (ULONG)tStart);
 454
 455     This->filter.state = State_Running;
 456
 457     return S_OK;
 458 }
 459
 460 /** IBaseFilter methods **/
 461
 462 static IPin* WINAPI AsyncReader_GetPin(IBaseFilter *iface, int pos)
 463 {
 464     AsyncReader *This = (AsyncReader *)iface;
 465
 466     if (pos >= 1 || !This->pOutputPin)
 467         return NULL;
 468
 469     IPin_AddRef(This->pOutputPin);
 470     return This->pOutputPin;
 471 }
 472
 473 static LONG WINAPI AsyncReader_GetPinCount(IBaseFilter *iface)
 474 {
 475     AsyncReader *This = (AsyncReader *)iface;
 476
 477     if (!This->pOutputPin)
 478         return 0;
 479     else
 480         return 1;
 481 }
 482
 483 static LONG WINAPI AsyncReader_GetPinVersion(IBaseFilter *iface)
 484 {
 485     AsyncReader *This = (AsyncReader *)iface;
 486
 487     /* Our pins are almost static, not changing so setting static tick count is ok */
 488     return This->lastpinchange;
 489 }
 490
 491 static HRESULT WINAPI AsyncReader_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 492 {
 493     AsyncReader *This = (AsyncReader *)iface;
 494
 495     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 496
 497     return EnumPins_Construct(iface, AsyncReader_GetPin, AsyncReader_GetPinCount, AsyncReader_GetPinVersion, ppEnum);
 498 }
 499
 500 static HRESULT WINAPI AsyncReader_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 501 {
 502     FIXME("(%s, %p)\n", debugstr_w(Id), ppPin);
 503
 504     return E_NOTIMPL;
 505 }
 506
 507 static const IBaseFilterVtbl AsyncReader_Vtbl =
 508 {
 509     AsyncReader_QueryInterface,
 510     BaseFilterImpl_AddRef,
 511     AsyncReader_Release,
 512     BaseFilterImpl_GetClassID,
 513     AsyncReader_Stop,
 514     AsyncReader_Pause,
 515     AsyncReader_Run,
 516     BaseFilterImpl_GetState,
 517     BaseFilterImpl_SetSyncSource,
 518     BaseFilterImpl_GetSyncSource,
 519     AsyncReader_EnumPins,
 520     AsyncReader_FindPin,
 521     BaseFilterImpl_QueryFilterInfo,
 522     BaseFilterImpl_JoinFilterGraph,
 523     BaseFilterImpl_QueryVendorInfo
 524 };
 525
 526 static HRESULT WINAPI FileSource_QueryInterface(IFileSourceFilter * iface, REFIID riid, LPVOID * ppv)
 527 {
 528     AsyncReader *This = impl_from_IFileSourceFilter(iface);
 529
 530     return IBaseFilter_QueryInterface((IFileSourceFilter*)&This->filter.lpVtbl, riid, ppv);
 531 }
 532
 533 static ULONG WINAPI FileSource_AddRef(IFileSourceFilter * iface)
 534 {
 535     AsyncReader *This = impl_from_IFileSourceFilter(iface);
 536
 537     return IBaseFilter_AddRef((IFileSourceFilter*)&This->filter.lpVtbl);
 538 }
 539
 540 static ULONG WINAPI FileSource_Release(IFileSourceFilter * iface)
 541 {
 542     AsyncReader *This = impl_from_IFileSourceFilter(iface);
 543
 544     return IBaseFilter_Release((IFileSourceFilter*)&This->filter.lpVtbl);
 545 }
 546
 547 static HRESULT WINAPI FileSource_Load(IFileSourceFilter * iface, LPCOLESTR pszFileName, const AM_MEDIA_TYPE * pmt)
 548 {
 549     HRESULT hr;
 550     HANDLE hFile;
 551     IAsyncReader * pReader = NULL;
 552     AsyncReader *This = impl_from_IFileSourceFilter(iface);
 553
 554     TRACE("(%s, %p)\n", debugstr_w(pszFileName), pmt);
 555
 556     /* open file */
 557     /* FIXME: check the sharing values that native uses */
 558     hFile = CreateFileW(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 559
 560     if (hFile == INVALID_HANDLE_VALUE)
 561     {
 562         return HRESULT_FROM_WIN32(GetLastError());
 563     }
 564
 565     /* create pin */
 566     hr = FileAsyncReader_Construct(hFile, (IBaseFilter *)&This->filter.lpVtbl, &This->filter.csFilter, &This->pOutputPin);
 567     This->lastpinchange = GetTickCount();
 568
 569     if (SUCCEEDED(hr))
 570         hr = IPin_QueryInterface(This->pOutputPin, &IID_IAsyncReader, (LPVOID *)&pReader);
 571
 572     /* store file name & media type */
 573     if (SUCCEEDED(hr))
 574     {
 575         CoTaskMemFree(This->pszFileName);
 576         if (This->pmt)
 577             FreeMediaType(This->pmt);
 578
 579         This->pszFileName = CoTaskMemAlloc((strlenW(pszFileName) + 1) * sizeof(WCHAR));
 580         strcpyW(This->pszFileName, pszFileName);
 581
 582         This->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 583         if (!pmt)
 584         {
 585             This->pmt->bFixedSizeSamples = TRUE;
 586             This->pmt->bTemporalCompression = FALSE;
 587             This->pmt->cbFormat = 0;
 588             This->pmt->pbFormat = NULL;
 589             This->pmt->pUnk = NULL;
 590             This->pmt->lSampleSize = 0;
 591             This->pmt->formattype = FORMAT_None;
 592             hr = GetClassMediaFile(pReader, pszFileName, &This->pmt->majortype, &This->pmt->subtype);
 593             if (FAILED(hr))
 594             {
 595                 CoTaskMemFree(This->pmt);
 596                 This->pmt = NULL;
 597             }
 598         }
 599         else
 600             CopyMediaType(This->pmt, pmt);
 601     }
 602
 603     if (pReader)
 604         IAsyncReader_Release(pReader);
 605
 606     if (FAILED(hr))
 607     {
 608         if (This->pOutputPin)
 609         {
 610             IPin_Release(This->pOutputPin);
 611             This->pOutputPin = NULL;
 612         }
 613
 614         CoTaskMemFree(This->pszFileName);
 615         if (This->pmt)
 616             FreeMediaType(This->pmt);
 617         This->pszFileName = NULL;
 618         This->pmt = NULL;
 619
 620         CloseHandle(hFile);
 621     }
 622
 623     /* FIXME: check return codes */
 624     return hr;
 625 }
 626
 627 static HRESULT WINAPI FileSource_GetCurFile(IFileSourceFilter * iface, LPOLESTR * ppszFileName, AM_MEDIA_TYPE * pmt)
 628 {
 629     AsyncReader *This = impl_from_IFileSourceFilter(iface);
 630
 631     TRACE("(%p, %p)\n", ppszFileName, pmt);
 632
 633     if (!ppszFileName)
 634         return E_POINTER;
 635
 636     /* copy file name & media type if available, otherwise clear the outputs */
 637     if (This->pszFileName)
 638     {
 639         *ppszFileName = CoTaskMemAlloc((strlenW(This->pszFileName) + 1) * sizeof(WCHAR));
 640         strcpyW(*ppszFileName, This->pszFileName);
 641     }
 642     else
 643         *ppszFileName = NULL;
 644
 645     if (pmt)
 646     {
 647         if (This->pmt)
 648             CopyMediaType(pmt, This->pmt);
 649         else
 650             ZeroMemory(pmt, sizeof(*pmt));
 651     }
 652
 653     return S_OK;
 654 }
 655
 656 static const IFileSourceFilterVtbl FileSource_Vtbl =
 657 {
 658     FileSource_QueryInterface,
 659     FileSource_AddRef,
 660     FileSource_Release,
 661     FileSource_Load,
 662     FileSource_GetCurFile
 663 };
 664
 665
 666 /* the dwUserData passed back to user */
 667 typedef struct DATAREQUEST
 668 {
 669     IMediaSample * pSample; /* sample passed to us by user */
 670     DWORD_PTR dwUserData; /* user data passed to us */
 671     OVERLAPPED ovl; /* our overlapped structure */
 672 } DATAREQUEST;
 673
 674 typedef struct FileAsyncReader
 675 {
 676     BaseOutputPin pin;
 677     const struct IAsyncReaderVtbl * lpVtblAR;
 678
 679     HANDLE hFile;
 680     BOOL bFlushing;
 681     /* Why would you need more? Every sample has its own handle */
 682     LONG queued_number;
 683     LONG samples;
 684     LONG oldest_sample;
 685     CRITICAL_SECTION csList; /* critical section to prevent concurrency issues */
 686     DATAREQUEST *sample_list;
 687
 688     /* Have a handle for every sample, and then one more as flushing handle */
 689     HANDLE *handle_list;
 690 } FileAsyncReader;
 691
 692 static inline FileAsyncReader *impl_from_IAsyncReader( IAsyncReader *iface )
 693 {
 694     return (FileAsyncReader *)((char*)iface - FIELD_OFFSET(FileAsyncReader, lpVtblAR));
 695 }
 696
 697 static HRESULT WINAPI FileAsyncReaderPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt)
 698 {
 699     FileAsyncReader *This = (FileAsyncReader *)iface;
 700     AM_MEDIA_TYPE *pmt_filter = ((AsyncReader *)This->pin.pin.pinInfo.pFilter)->pmt;
 701
 702     FIXME("(%p, %p)\n", iface, pmt);
 703
 704     if (IsEqualGUID(&pmt->majortype, &pmt_filter->majortype) &&
 705         IsEqualGUID(&pmt->subtype, &pmt_filter->subtype) &&
 706         IsEqualGUID(&pmt->formattype, &FORMAT_None))
 707         return S_OK;
 708
 709     return S_FALSE;
 710 }
 711
 712 static HRESULT WINAPI FileAsyncReaderPin_GetMediaType(IPin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
 713 {
 714     FileAsyncReader *This = (FileAsyncReader *)iface;
 715     if (iPosition < 0)
 716         return E_INVALIDARG;
 717     if (iPosition > 0)
 718         return VFW_S_NO_MORE_ITEMS;
 719     CopyMediaType(pmt, ((AsyncReader *)This->pin.pin.pinInfo.pFilter)->pmt);
 720     return S_OK;
 721 }
 722
 723 /* overridden pin functions */
 724
 725 static HRESULT WINAPI FileAsyncReaderPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
 726 {
 727     FileAsyncReader *This = (FileAsyncReader *)iface;
 728     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 729
 730     *ppv = NULL;
 731
 732     if (IsEqualIID(riid, &IID_IUnknown))
 733         *ppv = This;
 734     else if (IsEqualIID(riid, &IID_IPin))
 735         *ppv = This;
 736     else if (IsEqualIID(riid, &IID_IAsyncReader))
 737         *ppv = &This->lpVtblAR;
 738
 739     if (*ppv)
 740     {
 741         IUnknown_AddRef((IUnknown *)(*ppv));
 742         return S_OK;
 743     }
 744
 745     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IMediaSeeking))
 746         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 747
 748     return E_NOINTERFACE;
 749 }
 750
 751 static ULONG WINAPI FileAsyncReaderPin_Release(IPin * iface)
 752 {
 753     FileAsyncReader *This = (FileAsyncReader *)iface;
 754     ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
 755     int x;
 756
 757     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 758
 759     if (!refCount)
 760     {
 761         CoTaskMemFree(This->sample_list);
 762         if (This->handle_list)
 763         {
 764             for (x = 0; x <= This->samples; ++x)
 765                 CloseHandle(This->handle_list[x]);
 766             CoTaskMemFree(This->handle_list);
 767         }
 768         CloseHandle(This->hFile);
 769         This->csList.DebugInfo->Spare[0] = 0;
 770         DeleteCriticalSection(&This->csList);
 771         CoTaskMemFree(This);
 772         return 0;
 773     }
 774     return refCount;
 775 }
 776
 777 static HRESULT WINAPI FileAsyncReaderPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 778 {
 779     TRACE("(%p)\n", ppEnum);
 780
 781     return EnumMediaTypes_Construct(iface, FileAsyncReaderPin_GetMediaType, BasePinImpl_GetMediaTypeVersion, ppEnum);
 782 }
 783
 784 static const IPinVtbl FileAsyncReaderPin_Vtbl =
 785 {
 786     FileAsyncReaderPin_QueryInterface,
 787     BasePinImpl_AddRef,
 788     FileAsyncReaderPin_Release,
 789     BaseOutputPinImpl_Connect,
 790     BaseOutputPinImpl_ReceiveConnection,
 791     BasePinImpl_Disconnect,
 792     BasePinImpl_ConnectedTo,
 793     BasePinImpl_ConnectionMediaType,
 794     BasePinImpl_QueryPinInfo,
 795     BasePinImpl_QueryDirection,
 796     BasePinImpl_QueryId,
 797     FileAsyncReaderPin_QueryAccept,
 798     FileAsyncReaderPin_EnumMediaTypes,
 799     BasePinImpl_QueryInternalConnections,
 800     BaseOutputPinImpl_EndOfStream,
 801     BaseOutputPinImpl_BeginFlush,
 802     BaseOutputPinImpl_EndFlush,
 803     BaseOutputPinImpl_NewSegment
 804 };
 805
 806 /* Function called as a helper to IPin_Connect */
 807 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 808 /* this differs from standard OutputPin_AttemptConnection only in that it
 809  * doesn't need the IMemInputPin interface on the receiving pin */
 810 static HRESULT WINAPI FileAsyncReaderPin_AttemptConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 811 {
 812     BaseOutputPin *This = (BaseOutputPin *)iface;
 813     HRESULT hr;
 814
 815     TRACE("(%p, %p)\n", pReceivePin, pmt);
 816     dump_AM_MEDIA_TYPE(pmt);
 817
 818     /* FIXME: call queryacceptproc */
 819
 820     This->pin.pConnectedTo = pReceivePin;
 821     IPin_AddRef(pReceivePin);
 822     CopyMediaType(&This->pin.mtCurrent, pmt);
 823
 824     hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
 825
 826     if (FAILED(hr))
 827     {
 828         IPin_Release(This->pin.pConnectedTo);
 829         This->pin.pConnectedTo = NULL;
 830         FreeMediaType(&This->pin.mtCurrent);
 831     }
 832
 833     TRACE(" -- %x\n", hr);
 834     return hr;
 835 }
 836
 837 static HRESULT FileAsyncReader_Construct(HANDLE hFile, IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 838 {
 839     PIN_INFO piOutput;
 840     HRESULT hr;
 841
 842     *ppPin = NULL;
 843     piOutput.dir = PINDIR_OUTPUT;
 844     piOutput.pFilter = pBaseFilter;
 845     strcpyW(piOutput.achName, wszOutputPinName);
 846     hr = BaseOutputPin_Construct(&FileAsyncReaderPin_Vtbl, sizeof(FileAsyncReader), &piOutput, NULL, FileAsyncReaderPin_AttemptConnection, pCritSec, ppPin);
 847
 848     if (SUCCEEDED(hr))
 849     {
 850         FileAsyncReader *pPinImpl =  (FileAsyncReader *)*ppPin;
 851         pPinImpl->lpVtblAR = &FileAsyncReader_Vtbl;
 852         pPinImpl->hFile = hFile;
 853         pPinImpl->bFlushing = FALSE;
 854         pPinImpl->sample_list = NULL;
 855         pPinImpl->handle_list = NULL;
 856         pPinImpl->queued_number = 0;
 857         InitializeCriticalSection(&pPinImpl->csList);
 858         pPinImpl->csList.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FileAsyncReader.csList");
 859     }
 860     return hr;
 861 }
 862
 863 /* IAsyncReader */
 864
 865 static HRESULT WINAPI FileAsyncReader_QueryInterface(IAsyncReader * iface, REFIID riid, LPVOID * ppv)
 866 {
 867     FileAsyncReader *This = impl_from_IAsyncReader(iface);
 868
 869     return IPin_QueryInterface((IPin *)This, riid, ppv);
 870 }
 871
 872 static ULONG WINAPI FileAsyncReader_AddRef(IAsyncReader * iface)
 873 {
 874     FileAsyncReader *This = impl_from_IAsyncReader(iface);
 875
 876     return IPin_AddRef((IPin *)This);
 877 }
 878
 879 static ULONG WINAPI FileAsyncReader_Release(IAsyncReader * iface)
 880 {
 881     FileAsyncReader *This = impl_from_IAsyncReader(iface);
 882
 883     return IPin_Release((IPin *)This);
 884 }
 885
 886 #define DEF_ALIGNMENT 1
 887
 888 static HRESULT WINAPI FileAsyncReader_RequestAllocator(IAsyncReader * iface, IMemAllocator * pPreferred, ALLOCATOR_PROPERTIES * pProps, IMemAllocator ** ppActual)
 889 {
 890     FileAsyncReader *This = impl_from_IAsyncReader(iface);
 891
 892     HRESULT hr = S_OK;
 893
 894     TRACE("(%p, %p, %p)\n", pPreferred, pProps, ppActual);
 895
 896     if (!pProps->cbAlign || (pProps->cbAlign % DEF_ALIGNMENT) != 0)
 897         pProps->cbAlign = DEF_ALIGNMENT;
 898
 899     if (pPreferred)
 900     {
 901         hr = IMemAllocator_SetProperties(pPreferred, pProps, pProps);
 902         /* FIXME: check we are still aligned */
 903         if (SUCCEEDED(hr))
 904         {
 905             IMemAllocator_AddRef(pPreferred);
 906             *ppActual = pPreferred;
 907             TRACE("FileAsyncReader_RequestAllocator -- %x\n", hr);
 908             goto done;
 909         }
 910     }
 911
 912     pPreferred = NULL;
 913
 914     hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC, &IID_IMemAllocator, (LPVOID *)&pPreferred);
 915
 916     if (SUCCEEDED(hr))
 917     {
 918         hr = IMemAllocator_SetProperties(pPreferred, pProps, pProps);
 919         /* FIXME: check we are still aligned */
 920         if (SUCCEEDED(hr))
 921         {
 922             *ppActual = pPreferred;
 923             TRACE("FileAsyncReader_RequestAllocator -- %x\n", hr);
 924         }
 925     }
 926
 927 done:
 928     if (SUCCEEDED(hr))
 929     {
 930         CoTaskMemFree(This->sample_list);
 931         if (This->handle_list)
 932         {
 933             int x;
 934             for (x = 0; x <= This->samples; ++x)
 935                 CloseHandle(This->handle_list[x]);
 936             CoTaskMemFree(This->handle_list);
 937         }
 938
 939         This->samples = pProps->cBuffers;
 940         This->oldest_sample = 0;
 941         TRACE("Samples: %u\n", This->samples);
 942         This->sample_list = CoTaskMemAlloc(sizeof(This->sample_list[0]) * pProps->cBuffers);
 943         This->handle_list = CoTaskMemAlloc(sizeof(HANDLE) * pProps->cBuffers * 2);
 944
 945         if (This->sample_list && This->handle_list)
 946         {
 947             int x;
 948             ZeroMemory(This->sample_list, sizeof(This->sample_list[0]) * pProps->cBuffers);
 949             for (x = 0; x < This->samples; ++x)
 950             {
 951                 This->sample_list[x].ovl.hEvent = This->handle_list[x] = CreateEventW(NULL, 0, 0, NULL);
 952                 if (x + 1 < This->samples)
 953                     This->handle_list[This->samples + 1 + x] = This->handle_list[x];
 954             }
 955             This->handle_list[This->samples] = CreateEventW(NULL, 1, 0, NULL);
 956             This->pin.allocProps = *pProps;
 957         }
 958         else
 959         {
 960             hr = E_OUTOFMEMORY;
 961             CoTaskMemFree(This->sample_list);
 962             CoTaskMemFree(This->handle_list);
 963             This->samples = 0;
 964             This->sample_list = NULL;
 965             This->handle_list = NULL;
 966         }
 967     }
 968
 969     if (FAILED(hr))
 970     {
 971         *ppActual = NULL;
 972         if (pPreferred)
 973             IMemAllocator_Release(pPreferred);
 974     }
 975
 976     TRACE("-- %x\n", hr);
 977     return hr;
 978 }
 979
 980 /* we could improve the Request/WaitForNext mechanism by allowing out of order samples.
 981  * however, this would be quite complicated to do and may be a bit error prone */
 982 static HRESULT WINAPI FileAsyncReader_Request(IAsyncReader * iface, IMediaSample * pSample, DWORD_PTR dwUser)
 983 {
 984     HRESULT hr = S_OK;
 985     REFERENCE_TIME Start;
 986     REFERENCE_TIME Stop;
 987     FileAsyncReader *This = impl_from_IAsyncReader(iface);
 988     LPBYTE pBuffer = NULL;
 989
 990     TRACE("(%p, %lx)\n", pSample, dwUser);
 991
 992     if (!pSample)
 993         return E_POINTER;
 994
 995     /* get start and stop positions in bytes */
 996     if (SUCCEEDED(hr))
 997         hr = IMediaSample_GetTime(pSample, &Start, &Stop);
 998
 999     if (SUCCEEDED(hr))
1000         hr = IMediaSample_GetPointer(pSample, &pBuffer);
1001
1002     EnterCriticalSection(&This->csList);
1003     if (This->bFlushing)
1004     {
1005         LeaveCriticalSection(&This->csList);
1006         return VFW_E_WRONG_STATE;
1007     }
1008
1009     if (SUCCEEDED(hr))
1010     {
1011         DWORD dwLength = (DWORD) BYTES_FROM_MEDIATIME(Stop - Start);
1012         DATAREQUEST *pDataRq;
1013         int x;
1014
1015         /* Try to insert above the waiting sample if possible */
1016         for (x = This->oldest_sample; x < This->samples; ++x)
1017         {
1018             if (!This->sample_list[x].pSample)
1019                 break;
1020         }
1021
1022         if (x >= This->samples)
1023             for (x = 0; x < This->oldest_sample; ++x)
1024             {
1025                 if (!This->sample_list[x].pSample)
1026                     break;
1027             }
1028
1029         /* There must be a sample we have found */
1030         assert(x < This->samples);
1031         ++This->queued_number;
1032
1033         pDataRq = This->sample_list + x;
1034
1035         pDataRq->ovl.u.s.Offset = (DWORD) BYTES_FROM_MEDIATIME(Start);
1036         pDataRq->ovl.u.s.OffsetHigh = (DWORD)(BYTES_FROM_MEDIATIME(Start) >> (sizeof(DWORD) * 8));
1037         pDataRq->dwUserData = dwUser;
1038
1039         /* we violate traditional COM rules here by maintaining
1040          * a reference to the sample, but not calling AddRef, but
1041          * that's what MSDN says to do */
1042         pDataRq->pSample = pSample;
1043
1044         /* this is definitely not how it is implemented on Win9x
1045          * as they do not support async reads on files, but it is
1046          * sooo much easier to use this than messing around with threads!
1047          */
1048         if (!ReadFile(This->hFile, pBuffer, dwLength, NULL, &pDataRq->ovl))
1049             hr = HRESULT_FROM_WIN32(GetLastError());
1050
1051         /* ERROR_IO_PENDING is not actually an error since this is what we want! */
1052         if (hr == HRESULT_FROM_WIN32(ERROR_IO_PENDING))
1053             hr = S_OK;
1054     }
1055
1056     LeaveCriticalSection(&This->csList);
1057
1058     TRACE("-- %x\n", hr);
1059     return hr;
1060 }
1061
1062 static HRESULT WINAPI FileAsyncReader_WaitForNext(IAsyncReader * iface, DWORD dwTimeout, IMediaSample ** ppSample, DWORD_PTR * pdwUser)
1063 {
1064     HRESULT hr = S_OK;
1065     FileAsyncReader *This = impl_from_IAsyncReader(iface);
1066     DWORD buffer = ~0;
1067
1068     TRACE("(%u, %p, %p)\n", dwTimeout, ppSample, pdwUser);
1069
1070     *ppSample = NULL;
1071     *pdwUser = 0;
1072
1073     EnterCriticalSection(&This->csList);
1074     if (!This->bFlushing)
1075     {
1076         LONG oldest = This->oldest_sample;
1077
1078         if (!This->queued_number)
1079         {
1080             /* It could be that nothing is queued right now, but that can be fixed */
1081             WARN("Called without samples in queue and not flushing!!\n");
1082         }
1083         LeaveCriticalSection(&This->csList);
1084
1085         /* wait for an object to read, or time out */
1086         buffer = WaitForMultipleObjectsEx(This->samples+1, This->handle_list + oldest, FALSE, dwTimeout, TRUE);
1087
1088         EnterCriticalSection(&This->csList);
1089         if (buffer <= This->samples)
1090         {
1091             /* Re-scale the buffer back to normal */
1092             buffer += oldest;
1093
1094             /* Uh oh, we overshot the flusher handle, renormalize it back to 0..Samples-1 */
1095             if (buffer > This->samples)
1096                 buffer -= This->samples + 1;
1097             assert(buffer <= This->samples);
1098         }
1099
1100         if (buffer >= This->samples)
1101         {
1102             if (buffer != This->samples)
1103             {
1104                 FIXME("Returned: %u (%08x)\n", buffer, GetLastError());
1105                 hr = VFW_E_TIMEOUT;
1106             }
1107             else
1108                 hr = VFW_E_WRONG_STATE;
1109             buffer = ~0;
1110         }
1111         else
1112             --This->queued_number;
1113     }
1114
1115     if (This->bFlushing && buffer == ~0)
1116     {
1117         for (buffer = 0; buffer < This->samples; ++buffer)
1118         {
1119             if (This->sample_list[buffer].pSample)
1120             {
1121                 ResetEvent(This->handle_list[buffer]);
1122                 break;
1123             }
1124         }
1125         if (buffer == This->samples)
1126         {
1127             assert(!This->queued_number);
1128             hr = VFW_E_TIMEOUT;
1129         }
1130         else
1131         {
1132             --This->queued_number;
1133             hr = S_OK;
1134         }
1135     }
1136
1137     if (SUCCEEDED(hr))
1138     {
1139         REFERENCE_TIME rtStart, rtStop;
1140         REFERENCE_TIME rtSampleStart, rtSampleStop;
1141         DATAREQUEST *pDataRq = This->sample_list + buffer;
1142         DWORD dwBytes = 0;
1143
1144         /* get any errors */
1145         if (!This->bFlushing && !GetOverlappedResult(This->hFile, &pDataRq->ovl, &dwBytes, FALSE))
1146             hr = HRESULT_FROM_WIN32(GetLastError());
1147
1148         /* Return the sample no matter what so it can be destroyed */
1149         *ppSample = pDataRq->pSample;
1150         *pdwUser = pDataRq->dwUserData;
1151
1152         if (This->bFlushing)
1153             hr = VFW_E_WRONG_STATE;
1154
1155         if (FAILED(hr))
1156             dwBytes = 0;
1157
1158         /* Set the time on the sample */
1159         IMediaSample_SetActualDataLength(pDataRq->pSample, dwBytes);
1160
1161         rtStart = (DWORD64)pDataRq->ovl.u.s.Offset + ((DWORD64)pDataRq->ovl.u.s.OffsetHigh << 32);
1162         rtStart = MEDIATIME_FROM_BYTES(rtStart);
1163         rtStop = rtStart + MEDIATIME_FROM_BYTES(dwBytes);
1164
1165         IMediaSample_GetTime(pDataRq->pSample, &rtSampleStart, &rtSampleStop);
1166         assert(rtStart == rtSampleStart);
1167         assert(rtStop <= rtSampleStop);
1168
1169         IMediaSample_SetTime(pDataRq->pSample, &rtStart, &rtStop);
1170         assert(rtStart == rtSampleStart);
1171         if (hr == S_OK)
1172             assert(rtStop == rtSampleStop);
1173         else
1174             assert(rtStop == rtStart);
1175
1176         This->sample_list[buffer].pSample = NULL;
1177         assert(This->oldest_sample < This->samples);
1178
1179         if (buffer == This->oldest_sample)
1180         {
1181             LONG x;
1182             for (x = This->oldest_sample + 1; x < This->samples; ++x)
1183                 if (This->sample_list[x].pSample)
1184                     break;
1185             if (x >= This->samples)
1186                 for (x = 0; x < This->oldest_sample; ++x)
1187                     if (This->sample_list[x].pSample)
1188                         break;
1189             if (This->oldest_sample == x)
1190                 /* No samples found, reset to 0 */
1191                 x = 0;
1192             This->oldest_sample = x;
1193         }
1194     }
1195     LeaveCriticalSection(&This->csList);
1196
1197     TRACE("-- %x\n", hr);
1198     return hr;
1199 }
1200
1201 static HRESULT WINAPI FileAsyncReader_SyncRead(IAsyncReader * iface, LONGLONG llPosition, LONG lLength, BYTE * pBuffer);
1202
1203 static HRESULT WINAPI FileAsyncReader_SyncReadAligned(IAsyncReader * iface, IMediaSample * pSample)
1204 {
1205     BYTE * pBuffer;
1206     REFERENCE_TIME tStart;
1207     REFERENCE_TIME tStop;
1208     HRESULT hr;
1209
1210     TRACE("(%p)\n", pSample);
1211
1212     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
1213
1214     if (SUCCEEDED(hr))
1215         hr = IMediaSample_GetPointer(pSample, &pBuffer);
1216
1217     if (SUCCEEDED(hr))
1218         hr = FileAsyncReader_SyncRead(iface,
1219             BYTES_FROM_MEDIATIME(tStart),
1220             (LONG) BYTES_FROM_MEDIATIME(tStop - tStart),
1221             pBuffer);
1222
1223     TRACE("-- %x\n", hr);
1224     return hr;
1225 }
1226
1227 static HRESULT WINAPI FileAsyncReader_SyncRead(IAsyncReader * iface, LONGLONG llPosition, LONG lLength, BYTE * pBuffer)
1228 {
1229     OVERLAPPED ovl;
1230     HRESULT hr = S_OK;
1231     FileAsyncReader *This = impl_from_IAsyncReader(iface);
1232
1233     TRACE("(%x%08x, %d, %p)\n", (ULONG)(llPosition >> 32), (ULONG)llPosition, lLength, pBuffer);
1234
1235     ZeroMemory(&ovl, sizeof(ovl));
1236
1237     ovl.hEvent = CreateEventW(NULL, 0, 0, NULL);
1238     /* NOTE: llPosition is the actual byte position to start reading from */
1239     ovl.u.s.Offset = (DWORD) llPosition;
1240     ovl.u.s.OffsetHigh = (DWORD) (llPosition >> (sizeof(DWORD) * 8));
1241
1242     if (!ReadFile(This->hFile, pBuffer, lLength, NULL, &ovl))
1243         hr = HRESULT_FROM_WIN32(GetLastError());
1244
1245     if (hr == HRESULT_FROM_WIN32(ERROR_IO_PENDING))
1246         hr = S_OK;
1247
1248     if (SUCCEEDED(hr))
1249     {
1250         DWORD dwBytesRead;
1251
1252         if (!GetOverlappedResult(This->hFile, &ovl, &dwBytesRead, TRUE))
1253             hr = HRESULT_FROM_WIN32(GetLastError());
1254     }
1255
1256     CloseHandle(ovl.hEvent);
1257
1258     TRACE("-- %x\n", hr);
1259     return hr;
1260 }
1261
1262 static HRESULT WINAPI FileAsyncReader_Length(IAsyncReader * iface, LONGLONG * pTotal, LONGLONG * pAvailable)
1263 {
1264     DWORD dwSizeLow;
1265     DWORD dwSizeHigh;
1266     FileAsyncReader *This = impl_from_IAsyncReader(iface);
1267
1268     TRACE("(%p, %p)\n", pTotal, pAvailable);
1269
1270     if (((dwSizeLow = GetFileSize(This->hFile, &dwSizeHigh)) == -1) &&
1271         (GetLastError() != NO_ERROR))
1272         return HRESULT_FROM_WIN32(GetLastError());
1273
1274     *pTotal = (LONGLONG)dwSizeLow | (LONGLONG)dwSizeHigh << (sizeof(DWORD) * 8);
1275
1276     *pAvailable = *pTotal;
1277
1278     return S_OK;
1279 }
1280
1281 static HRESULT WINAPI FileAsyncReader_BeginFlush(IAsyncReader * iface)
1282 {
1283     FileAsyncReader *This = impl_from_IAsyncReader(iface);
1284
1285     TRACE("()\n");
1286
1287     EnterCriticalSection(&This->csList);
1288     This->bFlushing = TRUE;
1289     CancelIo(This->hFile);
1290     SetEvent(This->handle_list[This->samples]);
1291     LeaveCriticalSection(&This->csList);
1292
1293     return S_OK;
1294 }
1295
1296 static HRESULT WINAPI FileAsyncReader_EndFlush(IAsyncReader * iface)
1297 {
1298     FileAsyncReader *This = impl_from_IAsyncReader(iface);
1299     int x;
1300
1301     TRACE("()\n");
1302
1303     EnterCriticalSection(&This->csList);
1304     ResetEvent(This->handle_list[This->samples]);
1305     This->bFlushing = FALSE;
1306     for (x = 0; x < This->samples; ++x)
1307         assert(!This->sample_list[x].pSample);
1308
1309     LeaveCriticalSection(&This->csList);
1310
1311     return S_OK;
1312 }
1313
1314 static const IAsyncReaderVtbl FileAsyncReader_Vtbl =
1315 {
1316     FileAsyncReader_QueryInterface,
1317     FileAsyncReader_AddRef,
1318     FileAsyncReader_Release,
1319     FileAsyncReader_RequestAllocator,
1320     FileAsyncReader_Request,
1321     FileAsyncReader_WaitForNext,
1322     FileAsyncReader_SyncReadAligned,
1323     FileAsyncReader_SyncRead,
1324     FileAsyncReader_Length,
1325     FileAsyncReader_BeginFlush,
1326     FileAsyncReader_EndFlush,
1327 };