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