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