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