dlls/qasf/asfreader.c

   1 /*
   2  * WM ASF reader
   3  *
   4  * Copyright 2020 Jactry Zeng for CodeWeavers
   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 "qasf_private.h"
  22
  23 #include "mediaobj.h"
  24 #include "propsys.h"
  25 #include "initguid.h"
  26 #include "wmsdkidl.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  29
  30 static inline const char *debugstr_time(REFERENCE_TIME time)
  31 {
  32     ULONGLONG abstime = time >= 0 ? time : -time;
  33     unsigned int i = 0, j = 0;
  34     char buffer[23], rev[23];
  35
  36     while (abstime || i <= 8)
  37     {
  38         buffer[i++] = '0' + (abstime % 10);
  39         abstime /= 10;
  40         if (i == 7) buffer[i++] = '.';
  41     }
  42     if (time < 0) buffer[i++] = '-';
  43
  44     while (i--) rev[j++] = buffer[i];
  45     while (rev[j-1] == '0' && rev[j-2] != '.') --j;
  46     rev[j] = 0;
  47
  48     return wine_dbg_sprintf("%s", rev);
  49 }
  50
  51 struct buffer
  52 {
  53     INSSBuffer INSSBuffer_iface;
  54     LONG refcount;
  55     IMediaSample *sample;
  56 };
  57
  58 static struct buffer *impl_from_INSSBuffer(INSSBuffer *iface)
  59 {
  60     return CONTAINING_RECORD(iface, struct buffer, INSSBuffer_iface);
  61 }
  62
  63 static HRESULT WINAPI buffer_QueryInterface(INSSBuffer *iface, REFIID iid, void **out)
  64 {
  65     struct buffer *impl = impl_from_INSSBuffer(iface);
  66
  67     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  68
  69     if (IsEqualGUID(iid, &IID_IUnknown)
  70             || IsEqualGUID(iid, &IID_INSSBuffer))
  71         *out = &impl->INSSBuffer_iface;
  72     else
  73     {
  74         *out = NULL;
  75         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  76         return E_NOINTERFACE;
  77     }
  78
  79     IUnknown_AddRef((IUnknown *)*out);
  80     return S_OK;
  81 }
  82
  83 static ULONG WINAPI buffer_AddRef(INSSBuffer *iface)
  84 {
  85     struct buffer *impl = impl_from_INSSBuffer(iface);
  86     ULONG ref = InterlockedIncrement(&impl->refcount);
  87     TRACE("iface %p increasing refcount to %lu.\n", iface, ref);
  88     return ref;
  89 }
  90
  91 static ULONG WINAPI buffer_Release(INSSBuffer *iface)
  92 {
  93     struct buffer *impl = impl_from_INSSBuffer(iface);
  94     ULONG ref = InterlockedDecrement(&impl->refcount);
  95
  96     TRACE("iface %p decreasing refcount to %lu.\n", iface, ref);
  97
  98     if (!ref)
  99     {
 100         IMediaSample_Release(impl->sample);
 101         free(impl);
 102     }
 103
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI buffer_GetLength(INSSBuffer *iface, DWORD *size)
 108 {
 109     struct buffer *impl = impl_from_INSSBuffer(iface);
 110     TRACE("iface %p, size %p.\n", iface, size);
 111     *size = IMediaSample_GetActualDataLength(impl->sample);
 112     return S_OK;
 113 }
 114
 115 static HRESULT WINAPI buffer_SetLength(INSSBuffer *iface, DWORD size)
 116 {
 117     struct buffer *impl = impl_from_INSSBuffer(iface);
 118     TRACE("iface %p, size %lu.\n", iface, size);
 119     return IMediaSample_SetActualDataLength(impl->sample, size);
 120 }
 121
 122 static HRESULT WINAPI buffer_GetMaxLength(INSSBuffer *iface, DWORD *size)
 123 {
 124     struct buffer *impl = impl_from_INSSBuffer(iface);
 125     TRACE("iface %p, size %p.\n", iface, size);
 126     *size = IMediaSample_GetSize(impl->sample);
 127     return S_OK;
 128 }
 129
 130 static HRESULT WINAPI buffer_GetBuffer(INSSBuffer *iface, BYTE **data)
 131 {
 132     struct buffer *impl = impl_from_INSSBuffer(iface);
 133     TRACE("iface %p, data %p.\n", iface, data);
 134     return IMediaSample_GetPointer(impl->sample, data);
 135 }
 136
 137 static HRESULT WINAPI buffer_GetBufferAndLength(INSSBuffer *iface, BYTE **data, DWORD *size)
 138 {
 139     struct buffer *impl = impl_from_INSSBuffer(iface);
 140     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 141     *size = IMediaSample_GetSize(impl->sample);
 142     return IMediaSample_GetPointer(impl->sample, data);
 143 }
 144
 145 static const INSSBufferVtbl buffer_vtbl =
 146 {
 147     buffer_QueryInterface,
 148     buffer_AddRef,
 149     buffer_Release,
 150     buffer_GetLength,
 151     buffer_SetLength,
 152     buffer_GetMaxLength,
 153     buffer_GetBuffer,
 154     buffer_GetBufferAndLength,
 155 };
 156
 157 static HRESULT buffer_create(IMediaSample *sample, INSSBuffer **out)
 158 {
 159     struct buffer *buffer;
 160
 161     if (!(buffer = calloc(1, sizeof(struct buffer))))
 162         return E_OUTOFMEMORY;
 163
 164     buffer->INSSBuffer_iface.lpVtbl = &buffer_vtbl;
 165     buffer->refcount = 1;
 166     buffer->sample = sample;
 167
 168     *out = &buffer->INSSBuffer_iface;
 169     TRACE("Created buffer %p for sample %p\n", *out, sample);
 170
 171     return S_OK;
 172 }
 173
 174 static struct buffer *unsafe_impl_from_INSSBuffer(INSSBuffer *iface)
 175 {
 176     if (iface->lpVtbl != &buffer_vtbl) return NULL;
 177     return impl_from_INSSBuffer(iface);
 178 }
 179
 180 struct asf_stream
 181 {
 182     struct strmbase_source source;
 183     struct SourceSeeking seek;
 184     DWORD index;
 185 };
 186
 187 struct asf_reader
 188 {
 189     struct strmbase_filter filter;
 190     IFileSourceFilter IFileSourceFilter_iface;
 191
 192     WCHAR *file_name;
 193
 194     HRESULT result;
 195     WMT_STATUS status;
 196     CRITICAL_SECTION status_cs;
 197     CONDITION_VARIABLE status_cv;
 198
 199     IWMReaderCallback *callback;
 200     IWMReader *reader;
 201
 202     UINT stream_count;
 203     struct asf_stream streams[16];
 204 };
 205
 206 static inline struct asf_stream *impl_from_strmbase_pin(struct strmbase_pin *iface)
 207 {
 208     return CONTAINING_RECORD(iface, struct asf_stream, source.pin);
 209 }
 210
 211 static inline struct asf_reader *asf_reader_from_asf_stream(struct asf_stream *stream)
 212 {
 213     return CONTAINING_RECORD(stream, struct asf_reader, streams[stream->index]);
 214 }
 215
 216 static HRESULT asf_stream_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *media_type)
 217 {
 218     struct asf_stream *stream = impl_from_strmbase_pin(iface);
 219     struct asf_reader *filter = asf_reader_from_asf_stream(stream);
 220     IWMOutputMediaProps *props;
 221     WM_MEDIA_TYPE *mt;
 222     DWORD size, i = 0;
 223     HRESULT hr;
 224
 225     TRACE("iface %p, media_type %p.\n", iface, media_type);
 226
 227     if (FAILED(hr = IWMReader_GetOutputFormat(filter->reader, stream->index, i, &props)))
 228         return hr;
 229     if (FAILED(hr = IWMOutputMediaProps_GetMediaType(props, NULL, &size)))
 230     {
 231         IWMOutputMediaProps_Release(props);
 232         return hr;
 233     }
 234     if (!(mt = malloc(size)))
 235     {
 236         IWMOutputMediaProps_Release(props);
 237         return E_OUTOFMEMORY;
 238     }
 239
 240     do
 241     {
 242         if (SUCCEEDED(hr = IWMOutputMediaProps_GetMediaType(props, mt, &size))
 243                 && IsEqualGUID(&mt->majortype, &media_type->majortype)
 244                 && IsEqualGUID(&mt->subtype, &media_type->subtype))
 245         {
 246             IWMOutputMediaProps_Release(props);
 247             break;
 248         }
 249
 250         IWMOutputMediaProps_Release(props);
 251     } while (SUCCEEDED(hr = IWMReader_GetOutputFormat(filter->reader, stream->index, ++i, &props)));
 252
 253     free(mt);
 254     return hr;
 255 }
 256
 257 static HRESULT asf_stream_get_media_type(struct strmbase_pin *iface, unsigned int index, AM_MEDIA_TYPE *media_type)
 258 {
 259     struct asf_stream *stream = impl_from_strmbase_pin(iface);
 260     struct asf_reader *filter = asf_reader_from_asf_stream(stream);
 261     IWMOutputMediaProps *props;
 262     WM_MEDIA_TYPE *mt;
 263     DWORD size;
 264     HRESULT hr;
 265
 266     TRACE("iface %p, index %u, media_type %p.\n", iface, index, media_type);
 267
 268     if (FAILED(IWMReader_GetOutputFormat(filter->reader, stream->index, index, &props)))
 269         return VFW_S_NO_MORE_ITEMS;
 270     if (FAILED(hr = IWMOutputMediaProps_GetMediaType(props, NULL, &size)))
 271     {
 272         IWMOutputMediaProps_Release(props);
 273         return hr;
 274     }
 275     if (!(mt = malloc(size)))
 276     {
 277         IWMOutputMediaProps_Release(props);
 278         return E_OUTOFMEMORY;
 279     }
 280
 281     hr = IWMOutputMediaProps_GetMediaType(props, mt, &size);
 282     if (SUCCEEDED(hr))
 283         hr = CopyMediaType(media_type, (AM_MEDIA_TYPE *)mt);
 284
 285     free(mt);
 286     IWMOutputMediaProps_Release(props);
 287     return hr;
 288 }
 289
 290 static HRESULT asf_stream_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 291 {
 292     struct asf_stream *stream = impl_from_strmbase_pin(iface);
 293
 294     if (IsEqualGUID(iid, &IID_IMediaSeeking))
 295         *out = &stream->seek.IMediaSeeking_iface;
 296     else
 297         return E_NOINTERFACE;
 298
 299     IUnknown_AddRef((IUnknown *)*out);
 300     return S_OK;
 301 }
 302
 303 static inline struct asf_stream *impl_from_IMediaSeeking(IMediaSeeking *iface)
 304 {
 305     return CONTAINING_RECORD(iface, struct asf_stream, seek.IMediaSeeking_iface);
 306 }
 307
 308 static HRESULT WINAPI media_seeking_ChangeCurrent(IMediaSeeking *iface)
 309 {
 310     FIXME("iface %p stub!\n", iface);
 311     return S_OK;
 312 }
 313
 314 static HRESULT WINAPI media_seeking_ChangeStop(IMediaSeeking *iface)
 315 {
 316     FIXME("iface %p stub!\n", iface);
 317     return S_OK;
 318 }
 319
 320 static HRESULT WINAPI media_seeking_ChangeRate(IMediaSeeking *iface)
 321 {
 322     FIXME("iface %p stub!\n", iface);
 323     return S_OK;
 324 }
 325
 326 static HRESULT WINAPI media_seeking_QueryInterface(IMediaSeeking *iface, REFIID riid, void **ppv)
 327 {
 328     struct asf_stream *impl = impl_from_IMediaSeeking(iface);
 329     return IUnknown_QueryInterface(&impl->source.pin.IPin_iface, riid, ppv);
 330 }
 331
 332 static ULONG WINAPI media_seeking_AddRef(IMediaSeeking *iface)
 333 {
 334     struct asf_stream *impl = impl_from_IMediaSeeking(iface);
 335     return IUnknown_AddRef(&impl->source.pin.IPin_iface);
 336 }
 337
 338 static ULONG WINAPI media_seeking_Release(IMediaSeeking *iface)
 339 {
 340     struct asf_stream *impl = impl_from_IMediaSeeking(iface);
 341     return IUnknown_Release(&impl->source.pin.IPin_iface);
 342 }
 343
 344 static HRESULT WINAPI media_seeking_SetPositions(IMediaSeeking *iface,
 345         LONGLONG *current, DWORD current_flags, LONGLONG *stop, DWORD stop_flags)
 346 {
 347     FIXME("iface %p, current %s, current_flags %#lx, stop %s, stop_flags %#lx stub!\n",
 348             iface, current ? debugstr_time(*current) : "<null>", current_flags,
 349             stop ? debugstr_time(*stop) : "<null>", stop_flags);
 350     return SourceSeekingImpl_SetPositions(iface, current, current_flags, stop, stop_flags);
 351 }
 352
 353 static const IMediaSeekingVtbl media_seeking_vtbl =
 354 {
 355     media_seeking_QueryInterface,
 356     media_seeking_AddRef,
 357     media_seeking_Release,
 358     SourceSeekingImpl_GetCapabilities,
 359     SourceSeekingImpl_CheckCapabilities,
 360     SourceSeekingImpl_IsFormatSupported,
 361     SourceSeekingImpl_QueryPreferredFormat,
 362     SourceSeekingImpl_GetTimeFormat,
 363     SourceSeekingImpl_IsUsingTimeFormat,
 364     SourceSeekingImpl_SetTimeFormat,
 365     SourceSeekingImpl_GetDuration,
 366     SourceSeekingImpl_GetStopPosition,
 367     SourceSeekingImpl_GetCurrentPosition,
 368     SourceSeekingImpl_ConvertTimeFormat,
 369     media_seeking_SetPositions,
 370     SourceSeekingImpl_GetPositions,
 371     SourceSeekingImpl_GetAvailable,
 372     SourceSeekingImpl_SetRate,
 373     SourceSeekingImpl_GetRate,
 374     SourceSeekingImpl_GetPreroll,
 375 };
 376
 377 static inline struct asf_reader *impl_from_strmbase_filter(struct strmbase_filter *iface)
 378 {
 379     return CONTAINING_RECORD(iface, struct asf_reader, filter);
 380 }
 381
 382 static struct strmbase_pin *asf_reader_get_pin(struct strmbase_filter *iface, unsigned int index)
 383 {
 384     struct asf_reader *filter = impl_from_strmbase_filter(iface);
 385     struct strmbase_pin *pin = NULL;
 386
 387     TRACE("iface %p, index %u.\n", iface, index);
 388
 389     EnterCriticalSection(&filter->filter.filter_cs);
 390     if (index < filter->stream_count)
 391         pin = &filter->streams[index].source.pin;
 392     LeaveCriticalSection(&filter->filter.filter_cs);
 393
 394     return pin;
 395 }
 396
 397 static void asf_reader_destroy(struct strmbase_filter *iface)
 398 {
 399     struct asf_reader *filter = impl_from_strmbase_filter(iface);
 400     struct strmbase_source *source;
 401
 402     while (filter->stream_count--)
 403     {
 404         source = &filter->streams[filter->stream_count].source;
 405         if (source->pin.peer) IPin_Disconnect(source->pin.peer);
 406         IPin_Disconnect(&source->pin.IPin_iface);
 407         strmbase_source_cleanup(source);
 408     }
 409
 410     free(filter->file_name);
 411     IWMReaderCallback_Release(filter->callback);
 412     IWMReader_Release(filter->reader);
 413
 414     strmbase_filter_cleanup(&filter->filter);
 415
 416     filter->status_cs.DebugInfo->Spare[0] = 0;
 417     DeleteCriticalSection(&filter->status_cs);
 418
 419     free(filter);
 420 }
 421
 422 static HRESULT asf_reader_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
 423 {
 424     struct asf_reader *filter = impl_from_strmbase_filter(iface);
 425
 426     if (IsEqualGUID(iid, &IID_IFileSourceFilter))
 427     {
 428         *out = &filter->IFileSourceFilter_iface;
 429         IUnknown_AddRef((IUnknown *)*out);
 430         return S_OK;
 431     }
 432
 433     return E_NOINTERFACE;
 434 }
 435
 436 static HRESULT asf_reader_init_stream(struct strmbase_filter *iface)
 437 {
 438     struct asf_reader *filter = impl_from_strmbase_filter(iface);
 439     WMT_STREAM_SELECTION selections[ARRAY_SIZE(filter->streams)];
 440     WORD stream_numbers[ARRAY_SIZE(filter->streams)];
 441     IWMReaderAdvanced *reader_advanced;
 442     HRESULT hr = S_OK;
 443     int i;
 444
 445     TRACE("iface %p\n", iface);
 446
 447     if (FAILED(hr = IWMReader_QueryInterface(filter->reader, &IID_IWMReaderAdvanced, (void **)&reader_advanced)))
 448         return hr;
 449
 450     for (i = 0; i < filter->stream_count; ++i)
 451     {
 452         struct asf_stream *stream = filter->streams + i;
 453         IWMOutputMediaProps *props;
 454
 455         stream_numbers[i] = i + 1;
 456         selections[i] = WMT_OFF;
 457
 458         if (!stream->source.pin.peer)
 459             continue;
 460
 461         if (FAILED(hr = IMemAllocator_Commit(stream->source.pAllocator)))
 462         {
 463             WARN("Failed to commit stream %u allocator, hr %#lx\n", i, hr);
 464             break;
 465         }
 466
 467         if (FAILED(hr = IWMReaderAdvanced_SetAllocateForOutput(reader_advanced, i, TRUE)))
 468         {
 469             WARN("Failed to enable allocation for stream %u, hr %#lx\n", i, hr);
 470             break;
 471         }
 472
 473         if (FAILED(hr = IWMReader_GetOutputFormat(filter->reader, stream->index, 0, &props)))
 474         {
 475             WARN("Failed to get stream %u output format, hr %#lx\n", i, hr);
 476             break;
 477         }
 478
 479         hr = IWMOutputMediaProps_SetMediaType(props, (WM_MEDIA_TYPE *)&stream->source.pin.mt);
 480         if (SUCCEEDED(hr))
 481             hr = IWMReader_SetOutputProps(filter->reader, stream->index, props);
 482         IWMOutputMediaProps_Release(props);
 483         if (FAILED(hr))
 484         {
 485             WARN("Failed to set stream %u output format, hr %#lx\n", i, hr);
 486             break;
 487         }
 488
 489         if (FAILED(hr = IPin_NewSegment(stream->source.pin.peer, 0, 0, 1)))
 490         {
 491             WARN("Failed to start stream %u new segment, hr %#lx\n", i, hr);
 492             break;
 493         }
 494
 495         selections[i] = WMT_ON;
 496     }
 497
 498     if (SUCCEEDED(hr) && FAILED(hr = IWMReaderAdvanced_SetStreamsSelected(reader_advanced,
 499             filter->stream_count, stream_numbers, selections)))
 500         WARN("Failed to set reader %p stream selection, hr %#lx\n", filter->reader, hr);
 501
 502     IWMReaderAdvanced_Release(reader_advanced);
 503
 504     if (FAILED(hr))
 505         return hr;
 506
 507     EnterCriticalSection(&filter->status_cs);
 508     if (SUCCEEDED(hr = IWMReader_Start(filter->reader, 0, 0, 1, NULL)))
 509     {
 510         filter->status = -1;
 511         while (filter->status != WMT_STARTED)
 512             SleepConditionVariableCS(&filter->status_cv, &filter->status_cs, INFINITE);
 513         hr = filter->result;
 514     }
 515     LeaveCriticalSection(&filter->status_cs);
 516
 517     if (FAILED(hr))
 518         WARN("Failed to start WMReader %p, hr %#lx\n", filter->reader, hr);
 519
 520     return hr;
 521 }
 522
 523 static HRESULT asf_reader_cleanup_stream(struct strmbase_filter *iface)
 524 {
 525     struct asf_reader *filter = impl_from_strmbase_filter(iface);
 526     HRESULT hr = S_OK;
 527     int i;
 528
 529     TRACE("iface %p\n", iface);
 530
 531     EnterCriticalSection(&filter->status_cs);
 532     if (SUCCEEDED(hr = IWMReader_Stop(filter->reader)))
 533     {
 534         filter->status = -1;
 535         while (filter->status != WMT_STOPPED)
 536             SleepConditionVariableCS(&filter->status_cv, &filter->status_cs, INFINITE);
 537         hr = filter->result;
 538     }
 539     LeaveCriticalSection(&filter->status_cs);
 540
 541     if (FAILED(hr))
 542         WARN("Failed to stop WMReader %p, hr %#lx\n", filter->reader, hr);
 543
 544     for (i = 0; i < filter->stream_count; ++i)
 545     {
 546         struct asf_stream *stream = filter->streams + i;
 547
 548         if (!stream->source.pin.peer)
 549             continue;
 550
 551         if (FAILED(hr = IMemAllocator_Decommit(stream->source.pAllocator)))
 552         {
 553             WARN("Failed to decommit stream %u allocator, hr %#lx\n", i, hr);
 554             break;
 555         }
 556     }
 557
 558     return hr;
 559 }
 560
 561 static const struct strmbase_filter_ops filter_ops =
 562 {
 563     .filter_get_pin = asf_reader_get_pin,
 564     .filter_destroy = asf_reader_destroy,
 565     .filter_query_interface = asf_reader_query_interface,
 566     .filter_init_stream = asf_reader_init_stream,
 567     .filter_cleanup_stream = asf_reader_cleanup_stream,
 568 };
 569
 570 static HRESULT WINAPI asf_reader_DecideBufferSize(struct strmbase_source *iface,
 571         IMemAllocator *allocator, ALLOCATOR_PROPERTIES *req_props)
 572 {
 573     struct asf_stream *stream = impl_from_strmbase_pin(&iface->pin);
 574     unsigned int buffer_size = 16384;
 575     ALLOCATOR_PROPERTIES ret_props;
 576
 577     TRACE("iface %p, allocator %p, req_props %p.\n", iface, allocator, req_props);
 578
 579     if (IsEqualGUID(&stream->source.pin.mt.formattype, &FORMAT_VideoInfo))
 580     {
 581         VIDEOINFOHEADER *format = (VIDEOINFOHEADER *)stream->source.pin.mt.pbFormat;
 582         buffer_size = format->bmiHeader.biSizeImage;
 583     }
 584     else if (IsEqualGUID(&stream->source.pin.mt.formattype, &FORMAT_WaveFormatEx)
 585             && (IsEqualGUID(&stream->source.pin.mt.subtype, &MEDIASUBTYPE_PCM)
 586             || IsEqualGUID(&stream->source.pin.mt.subtype, &MEDIASUBTYPE_IEEE_FLOAT)))
 587     {
 588         WAVEFORMATEX *format = (WAVEFORMATEX *)stream->source.pin.mt.pbFormat;
 589         buffer_size = format->nAvgBytesPerSec;
 590     }
 591
 592     req_props->cBuffers = max(req_props->cBuffers, 1);
 593     req_props->cbBuffer = max(req_props->cbBuffer, buffer_size);
 594     req_props->cbAlign = max(req_props->cbAlign, 1);
 595     return IMemAllocator_SetProperties(allocator, req_props, &ret_props);
 596 }
 597
 598 static const struct strmbase_source_ops source_ops =
 599 {
 600     .base.pin_query_accept = asf_stream_query_accept,
 601     .base.pin_get_media_type = asf_stream_get_media_type,
 602     .base.pin_query_interface = asf_stream_query_interface,
 603     .pfnDecideAllocator = BaseOutputPinImpl_DecideAllocator,
 604     .pfnAttemptConnection = BaseOutputPinImpl_AttemptConnection,
 605     .pfnDecideBufferSize = asf_reader_DecideBufferSize,
 606 };
 607
 608 static inline struct asf_reader *impl_from_IFileSourceFilter(IFileSourceFilter *iface)
 609 {
 610     return CONTAINING_RECORD(iface, struct asf_reader, IFileSourceFilter_iface);
 611 }
 612
 613 static HRESULT WINAPI file_source_QueryInterface(IFileSourceFilter *iface, REFIID iid, void **out)
 614 {
 615     struct asf_reader *filter = impl_from_IFileSourceFilter(iface);
 616
 617     return IBaseFilter_QueryInterface(&filter->filter.IBaseFilter_iface, iid, out);
 618 }
 619
 620 static ULONG WINAPI file_source_AddRef(IFileSourceFilter *iface)
 621 {
 622     struct asf_reader *filter = impl_from_IFileSourceFilter(iface);
 623
 624     return IBaseFilter_AddRef(&filter->filter.IBaseFilter_iface);
 625 }
 626
 627 static ULONG WINAPI file_source_Release(IFileSourceFilter *iface)
 628 {
 629     struct asf_reader *filter = impl_from_IFileSourceFilter(iface);
 630
 631     return IBaseFilter_Release(&filter->filter.IBaseFilter_iface);
 632 }
 633
 634 static HRESULT WINAPI file_source_Load(IFileSourceFilter *iface, LPCOLESTR file_name, const AM_MEDIA_TYPE *media_type)
 635 {
 636     struct asf_reader *filter = impl_from_IFileSourceFilter(iface);
 637     HRESULT hr;
 638
 639     TRACE("filter %p, file_name %s, media_type %p.\n", filter, debugstr_w(file_name), media_type);
 640     strmbase_dump_media_type(media_type);
 641
 642     if (!file_name)
 643         return E_POINTER;
 644
 645     EnterCriticalSection(&filter->filter.filter_cs);
 646
 647     if (filter->file_name || !(filter->file_name = wcsdup(file_name)))
 648     {
 649         LeaveCriticalSection(&filter->filter.filter_cs);
 650         return E_FAIL;
 651     }
 652
 653     EnterCriticalSection(&filter->status_cs);
 654     if (SUCCEEDED(hr = IWMReader_Open(filter->reader, filter->file_name, filter->callback, NULL)))
 655     {
 656         filter->status = -1;
 657         while (filter->status != WMT_OPENED)
 658             SleepConditionVariableCS(&filter->status_cv, &filter->status_cs, INFINITE);
 659         hr = filter->result;
 660     }
 661     LeaveCriticalSection(&filter->status_cs);
 662
 663     if (FAILED(hr))
 664         WARN("Failed to open WM reader, hr %#lx.\n", hr);
 665
 666     LeaveCriticalSection(&filter->filter.filter_cs);
 667
 668     return S_OK;
 669 }
 670
 671 static HRESULT WINAPI file_source_GetCurFile(IFileSourceFilter *iface, LPOLESTR *file_name, AM_MEDIA_TYPE *media_type)
 672 {
 673     struct asf_reader *filter = impl_from_IFileSourceFilter(iface);
 674
 675     TRACE("filter %p, file_name %p, media_type %p.\n", filter, file_name, media_type);
 676
 677     if (!file_name)
 678         return E_POINTER;
 679     *file_name = NULL;
 680
 681     if (media_type)
 682     {
 683         media_type->majortype = GUID_NULL;
 684         media_type->subtype = GUID_NULL;
 685         media_type->lSampleSize = 0;
 686         media_type->pUnk = NULL;
 687         media_type->cbFormat = 0;
 688     }
 689
 690     if (filter->file_name)
 691     {
 692         *file_name = CoTaskMemAlloc((wcslen(filter->file_name) + 1) * sizeof(WCHAR));
 693         wcscpy(*file_name, filter->file_name);
 694     }
 695
 696     return S_OK;
 697 }
 698
 699 static const IFileSourceFilterVtbl file_source_vtbl =
 700 {
 701     file_source_QueryInterface,
 702     file_source_AddRef,
 703     file_source_Release,
 704     file_source_Load,
 705     file_source_GetCurFile,
 706 };
 707
 708 struct asf_callback
 709 {
 710     IWMReaderCallback IWMReaderCallback_iface;
 711     IWMReaderCallbackAdvanced IWMReaderCallbackAdvanced_iface;
 712     LONG ref;
 713
 714     struct asf_reader *filter;
 715 };
 716
 717 static inline struct asf_callback *impl_from_IWMReaderCallback(IWMReaderCallback *iface)
 718 {
 719     return CONTAINING_RECORD(iface, struct asf_callback, IWMReaderCallback_iface);
 720 }
 721
 722 static HRESULT WINAPI reader_callback_QueryInterface(IWMReaderCallback *iface, const IID *iid, void **out)
 723 {
 724     struct asf_callback *callback = impl_from_IWMReaderCallback(iface);
 725
 726     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 727
 728     if (IsEqualGUID(iid, &IID_IUnknown)
 729             || IsEqualGUID(iid, &IID_IWMStatusCallback)
 730             || IsEqualGUID(iid, &IID_IWMReaderCallback))
 731         *out = &callback->IWMReaderCallback_iface;
 732     else if (IsEqualGUID(iid, &IID_IWMReaderCallbackAdvanced))
 733         *out = &callback->IWMReaderCallbackAdvanced_iface;
 734     else
 735     {
 736         *out = NULL;
 737         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 738         return E_NOINTERFACE;
 739     }
 740
 741     IUnknown_AddRef((IUnknown *)*out);
 742     return S_OK;
 743 }
 744
 745 static ULONG WINAPI reader_callback_AddRef(IWMReaderCallback *iface)
 746 {
 747     struct asf_callback *callback = impl_from_IWMReaderCallback(iface);
 748     ULONG ref = InterlockedIncrement(&callback->ref);
 749
 750     TRACE("%p increasing ref to %lu.\n", callback, ref);
 751
 752     return ref;
 753 }
 754
 755 static ULONG WINAPI reader_callback_Release(IWMReaderCallback *iface)
 756 {
 757     struct asf_callback *callback = impl_from_IWMReaderCallback(iface);
 758     ULONG ref = InterlockedDecrement(&callback->ref);
 759
 760     TRACE("%p decreasing ref to %lu.\n", callback, ref);
 761
 762     if (!ref)
 763         free(callback);
 764
 765     return ref;
 766 }
 767
 768 static HRESULT WINAPI reader_callback_OnStatus(IWMReaderCallback *iface, WMT_STATUS status, HRESULT result,
 769         WMT_ATTR_DATATYPE type, BYTE *value, void *context)
 770 {
 771     struct asf_reader *filter = impl_from_IWMReaderCallback(iface)->filter;
 772     AM_MEDIA_TYPE stream_media_type = {{0}};
 773     IWMHeaderInfo *header_info;
 774     DWORD i, stream_count;
 775     WCHAR name[MAX_PATH];
 776     QWORD duration;
 777     HRESULT hr;
 778
 779     TRACE("iface %p, status %d, result %#lx, type %d, value %p, context %p.\n",
 780             iface, status, result, type, value, context);
 781
 782     switch (status)
 783     {
 784         case WMT_OPENED:
 785             if (FAILED(hr = IWMReader_GetOutputCount(filter->reader, &stream_count)))
 786             {
 787                 ERR("Failed to get WMReader output count, hr %#lx.\n", hr);
 788                 stream_count = 0;
 789             }
 790             if (stream_count > ARRAY_SIZE(filter->streams))
 791             {
 792                 FIXME("Found %lu streams, not supported!\n", stream_count);
 793                 stream_count = ARRAY_SIZE(filter->streams);
 794             }
 795
 796             if (FAILED(hr = IWMReader_QueryInterface(filter->reader, &IID_IWMHeaderInfo,
 797                     (void **)&header_info)))
 798                 duration = 0;
 799             else
 800             {
 801                 WMT_ATTR_DATATYPE type = WMT_TYPE_QWORD;
 802                 WORD index = 0, size = sizeof(duration);
 803
 804                 if (FAILED(IWMHeaderInfo_GetAttributeByName(header_info, &index, L"Duration",
 805                         &type, (BYTE *)&duration, &size )))
 806                     duration = 0;
 807                 IWMHeaderInfo_Release(header_info);
 808             }
 809
 810             for (i = 0; i < stream_count; ++i)
 811             {
 812                 struct asf_stream *stream = filter->streams + i;
 813
 814                 if (FAILED(hr = asf_stream_get_media_type(&stream->source.pin, 0, &stream_media_type)))
 815                     WARN("Failed to get stream media type, hr %#lx.\n", hr);
 816                 if (IsEqualGUID(&stream_media_type.majortype, &MEDIATYPE_Video))
 817                     swprintf(name, ARRAY_SIZE(name), L"Raw Video %u", stream->index);
 818                 else
 819                     swprintf(name, ARRAY_SIZE(name), L"Raw Audio %u", stream->index);
 820                 FreeMediaType(&stream_media_type);
 821
 822                 strmbase_source_init(&stream->source, &filter->filter, name, &source_ops);
 823                 strmbase_seeking_init(&stream->seek, &media_seeking_vtbl, media_seeking_ChangeStop,
 824                         media_seeking_ChangeCurrent, media_seeking_ChangeRate);
 825                 stream->seek.llCurrent = 0;
 826                 stream->seek.llDuration = duration;
 827                 stream->seek.llStop = duration;
 828             }
 829             filter->stream_count = stream_count;
 830             BaseFilterImpl_IncrementPinVersion(&filter->filter);
 831
 832             EnterCriticalSection(&filter->status_cs);
 833             filter->result = result;
 834             filter->status = WMT_OPENED;
 835             LeaveCriticalSection(&filter->status_cs);
 836             WakeConditionVariable(&filter->status_cv);
 837             break;
 838
 839         case WMT_END_OF_STREAMING:
 840             for (i = 0; i < filter->stream_count; ++i)
 841             {
 842                 struct asf_stream *stream = filter->streams + i;
 843
 844                 if (!stream->source.pin.peer)
 845                     continue;
 846
 847                 IPin_EndOfStream(stream->source.pin.peer);
 848             }
 849             break;
 850
 851         case WMT_STARTED:
 852             EnterCriticalSection(&filter->status_cs);
 853             filter->result = result;
 854             filter->status = WMT_STARTED;
 855             LeaveCriticalSection(&filter->status_cs);
 856             WakeConditionVariable(&filter->status_cv);
 857             break;
 858
 859         case WMT_STOPPED:
 860             EnterCriticalSection(&filter->status_cs);
 861             filter->result = result;
 862             filter->status = WMT_STOPPED;
 863             LeaveCriticalSection(&filter->status_cs);
 864             WakeConditionVariable(&filter->status_cv);
 865             break;
 866
 867         default:
 868             WARN("Ignoring status %#x.\n", status);
 869             break;
 870     }
 871
 872     return S_OK;
 873 }
 874
 875 static HRESULT WINAPI reader_callback_OnSample(IWMReaderCallback *iface, DWORD output, QWORD time,
 876         QWORD duration, DWORD flags, INSSBuffer *sample, void *context)
 877 {
 878     struct asf_reader *filter = impl_from_IWMReaderCallback(iface)->filter;
 879     REFERENCE_TIME start_time = time, end_time = time + duration;
 880     struct asf_stream *stream = filter->streams + output;
 881     struct buffer *buffer;
 882     HRESULT hr = S_OK;
 883
 884     TRACE("iface %p, output %lu, time %I64u, duration %I64u, flags %#lx, sample %p, context %p.\n",
 885             iface, output, time, duration, flags, sample, context);
 886
 887     if (!stream->source.pin.peer)
 888     {
 889         WARN("Output %lu pin is not connected, discarding %p.\n", output, sample);
 890         return S_OK;
 891     }
 892
 893     if (!(buffer = unsafe_impl_from_INSSBuffer(sample)))
 894         WARN("Unexpected buffer iface %p, discarding.\n", sample);
 895     else
 896     {
 897         IMediaSample_SetTime(buffer->sample, &start_time, &end_time);
 898         IMediaSample_SetDiscontinuity(buffer->sample, !!(flags & WM_SF_DISCONTINUITY));
 899         IMediaSample_SetSyncPoint(buffer->sample, !!(flags & WM_SF_CLEANPOINT));
 900
 901         hr = IMemInputPin_Receive(stream->source.pMemInputPin, buffer->sample);
 902
 903         TRACE("Receive returned hr %#lx.\n", hr);
 904     }
 905
 906     return hr;
 907 }
 908
 909 static const IWMReaderCallbackVtbl reader_callback_vtbl =
 910 {
 911     reader_callback_QueryInterface,
 912     reader_callback_AddRef,
 913     reader_callback_Release,
 914     reader_callback_OnStatus,
 915     reader_callback_OnSample,
 916 };
 917
 918 static inline struct asf_callback *impl_from_IWMReaderCallbackAdvanced(IWMReaderCallbackAdvanced *iface)
 919 {
 920     return CONTAINING_RECORD(iface, struct asf_callback, IWMReaderCallbackAdvanced_iface);
 921 }
 922
 923 static HRESULT WINAPI reader_callback_advanced_QueryInterface(IWMReaderCallbackAdvanced *iface, REFIID riid, LPVOID * ppv)
 924 {
 925     struct asf_callback *impl = impl_from_IWMReaderCallbackAdvanced(iface);
 926     return IUnknown_QueryInterface(&impl->IWMReaderCallback_iface, riid, ppv);
 927 }
 928
 929 static ULONG WINAPI reader_callback_advanced_AddRef(IWMReaderCallbackAdvanced *iface)
 930 {
 931     struct asf_callback *impl = impl_from_IWMReaderCallbackAdvanced(iface);
 932     return IUnknown_AddRef(&impl->IWMReaderCallback_iface);
 933 }
 934
 935 static ULONG WINAPI reader_callback_advanced_Release(IWMReaderCallbackAdvanced *iface)
 936 {
 937     struct asf_callback *impl = impl_from_IWMReaderCallbackAdvanced(iface);
 938     return IUnknown_Release(&impl->IWMReaderCallback_iface);
 939 }
 940
 941 static HRESULT WINAPI reader_callback_advanced_OnStreamSample(IWMReaderCallbackAdvanced *iface,
 942         WORD stream, QWORD time, QWORD duration, DWORD flags, INSSBuffer *sample, void *context)
 943 {
 944     FIXME("iface %p, stream %u, time %I64u, duration %I64u, flags %#lx, sample %p, context %p stub!\n",
 945             iface, stream, time, duration, flags, sample, context);
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI reader_callback_advanced_OnTime(IWMReaderCallbackAdvanced *iface,
 950         QWORD time, void *context)
 951 {
 952     FIXME("iface %p stub!\n", iface);
 953     return E_NOTIMPL;
 954 }
 955
 956 static HRESULT WINAPI reader_callback_advanced_OnStreamSelection(IWMReaderCallbackAdvanced *iface,
 957         WORD count, WORD *stream_numbers, WMT_STREAM_SELECTION *selections, void *context)
 958 {
 959     FIXME("iface %p stub!\n", iface);
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI reader_callback_advanced_OnOutputPropsChanged(IWMReaderCallbackAdvanced *iface,
 964         DWORD output, WM_MEDIA_TYPE *mt, void *context)
 965 {
 966     FIXME("iface %p stub!\n", iface);
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI reader_callback_advanced_AllocateForStream(IWMReaderCallbackAdvanced *iface,
 971         WORD stream, DWORD size, INSSBuffer **out, void *context)
 972 {
 973     FIXME("iface %p stub!\n", iface);
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI reader_callback_advanced_AllocateForOutput(IWMReaderCallbackAdvanced *iface,
 978         DWORD output, DWORD size, INSSBuffer **out, void *context)
 979 {
 980     struct asf_reader *filter = impl_from_IWMReaderCallbackAdvanced(iface)->filter;
 981     struct asf_stream *stream = filter->streams + output;
 982     IMediaSample *sample;
 983     HRESULT hr;
 984
 985     TRACE("iface %p, output %lu, size %lu, out %p, context %p.\n", iface, output, size, out, context);
 986
 987     *out = NULL;
 988
 989     if (!stream->source.pin.peer)
 990         return VFW_E_NOT_CONNECTED;
 991
 992     if (FAILED(hr = IMemAllocator_GetBuffer(stream->source.pAllocator, &sample, NULL, NULL, 0)))
 993     {
 994         WARN("Failed to get a sample, hr %#lx.\n", hr);
 995         return hr;
 996     }
 997
 998     if (size > IMediaSample_GetSize(sample))
 999     {
1000         WARN("Allocated media sample is too small, size %lu.\n", size);
1001         IMediaSample_Release(sample);
1002         return VFW_E_BUFFER_OVERFLOW;
1003     }
1004
1005     return buffer_create(sample, out);
1006 }
1007
1008 static const IWMReaderCallbackAdvancedVtbl reader_callback_advanced_vtbl =
1009 {
1010     reader_callback_advanced_QueryInterface,
1011     reader_callback_advanced_AddRef,
1012     reader_callback_advanced_Release,
1013     reader_callback_advanced_OnStreamSample,
1014     reader_callback_advanced_OnTime,
1015     reader_callback_advanced_OnStreamSelection,
1016     reader_callback_advanced_OnOutputPropsChanged,
1017     reader_callback_advanced_AllocateForStream,
1018     reader_callback_advanced_AllocateForOutput,
1019 };
1020
1021 static HRESULT asf_callback_create(struct asf_reader *filter, IWMReaderCallback **out)
1022 {
1023     struct asf_callback *callback;
1024
1025     if (!(callback = calloc(1, sizeof(*callback))))
1026         return E_OUTOFMEMORY;
1027
1028     callback->IWMReaderCallback_iface.lpVtbl = &reader_callback_vtbl;
1029     callback->IWMReaderCallbackAdvanced_iface.lpVtbl = &reader_callback_advanced_vtbl;
1030     callback->filter = filter;
1031     callback->ref = 1;
1032
1033     *out = &callback->IWMReaderCallback_iface;
1034     return S_OK;
1035 }
1036
1037 HRESULT asf_reader_create(IUnknown *outer, IUnknown **out)
1038 {
1039     struct asf_reader *object;
1040     HRESULT hr;
1041     int i;
1042
1043     if (!(object = calloc(1, sizeof(*object))))
1044         return E_OUTOFMEMORY;
1045
1046     if (FAILED(hr = WMCreateReader(NULL, 0, &object->reader)))
1047     {
1048         free(object);
1049         return hr;
1050     }
1051     if (FAILED(hr = asf_callback_create(object, &object->callback)))
1052     {
1053         IWMReader_Release(object->reader);
1054         free(object);
1055         return hr;
1056     }
1057
1058     for (i = 0; i < ARRAY_SIZE(object->streams); ++i) object->streams[i].index = i;
1059     strmbase_filter_init(&object->filter, outer, &CLSID_WMAsfReader, &filter_ops);
1060     object->IFileSourceFilter_iface.lpVtbl = &file_source_vtbl;
1061
1062     InitializeCriticalSection(&object->status_cs);
1063     object->status_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": status_cs");
1064
1065     TRACE("Created WM ASF reader %p.\n", object);
1066     *out = &object->filter.IUnknown_inner;
1067
1068     return S_OK;
1069 }