dlls/qedit/mediadet.c

   1 /*              DirectShow Media Detector object (QEDIT.DLL)
   2  *
   3  * Copyright 2008 Google (Lei Zhang, Dan Hipschman)
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <assert.h>
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29
  30 #include "qedit_private.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(qedit);
  34
  35 typedef struct MediaDetImpl {
  36     IUnknown IUnknown_inner;
  37     IMediaDet IMediaDet_iface;
  38     IUnknown *outer_unk;
  39     LONG ref;
  40     IGraphBuilder *graph;
  41     IBaseFilter *source;
  42     IBaseFilter *splitter;
  43     WCHAR *filename;
  44     LONG num_streams;
  45     LONG cur_stream;
  46     IPin *cur_pin;
  47 } MediaDetImpl;
  48
  49 static inline MediaDetImpl *impl_from_IUnknown(IUnknown *iface)
  50 {
  51     return CONTAINING_RECORD(iface, MediaDetImpl, IUnknown_inner);
  52 }
  53
  54 static inline MediaDetImpl *impl_from_IMediaDet(IMediaDet *iface)
  55 {
  56     return CONTAINING_RECORD(iface, MediaDetImpl, IMediaDet_iface);
  57 }
  58
  59 static void MD_cleanup(MediaDetImpl *This)
  60 {
  61     if (This->cur_pin) IPin_Release(This->cur_pin);
  62     This->cur_pin = NULL;
  63     if (This->source) IBaseFilter_Release(This->source);
  64     This->source = NULL;
  65     if (This->splitter) IBaseFilter_Release(This->splitter);
  66     This->splitter = NULL;
  67     if (This->graph) IGraphBuilder_Release(This->graph);
  68     This->graph = NULL;
  69     if (This->filename)
  70         free(This->filename);
  71     This->filename = NULL;
  72     This->num_streams = -1;
  73     This->cur_stream = 0;
  74 }
  75
  76 static HRESULT get_filter_info(IMoniker *moniker, GUID *clsid, VARIANT *var)
  77 {
  78     IPropertyBag *prop_bag;
  79     HRESULT hr;
  80
  81     if (FAILED(hr = IMoniker_BindToStorage(moniker, NULL, NULL, &IID_IPropertyBag, (void **)&prop_bag)))
  82     {
  83         ERR("Failed to get property bag, hr %#x.\n", hr);
  84         return hr;
  85     }
  86
  87     VariantInit(var);
  88     V_VT(var) = VT_BSTR;
  89     if (FAILED(hr = IPropertyBag_Read(prop_bag, L"CLSID", var, NULL)))
  90     {
  91         ERR("Failed to get CLSID, hr %#x.\n", hr);
  92         IPropertyBag_Release(prop_bag);
  93         return hr;
  94     }
  95     CLSIDFromString(V_BSTR(var), clsid);
  96     VariantClear(var);
  97
  98     if (FAILED(hr = IPropertyBag_Read(prop_bag, L"FriendlyName", var, NULL)))
  99         ERR("Failed to get name, hr %#x.\n", hr);
 100
 101     IPropertyBag_Release(prop_bag);
 102     return hr;
 103 }
 104
 105 static HRESULT get_pin_media_type(IPin *pin, AM_MEDIA_TYPE *out)
 106 {
 107     IEnumMediaTypes *enummt;
 108     AM_MEDIA_TYPE *pmt;
 109     HRESULT hr;
 110
 111     if (FAILED(hr = IPin_EnumMediaTypes(pin, &enummt)))
 112         return hr;
 113     hr = IEnumMediaTypes_Next(enummt, 1, &pmt, NULL);
 114     IEnumMediaTypes_Release(enummt);
 115     if (hr != S_OK)
 116         return E_NOINTERFACE;
 117
 118     *out = *pmt;
 119     CoTaskMemFree(pmt);
 120     return S_OK;
 121 }
 122
 123 static HRESULT find_splitter(MediaDetImpl *detector)
 124 {
 125     IPin *source_pin, *splitter_pin;
 126     IEnumMoniker *enum_moniker;
 127     IFilterMapper2 *mapper;
 128     IBaseFilter *splitter;
 129     IEnumPins *enum_pins;
 130     AM_MEDIA_TYPE mt;
 131     IMoniker *mon;
 132     GUID type[2];
 133     VARIANT var;
 134     HRESULT hr;
 135     GUID clsid;
 136
 137     if (FAILED(hr = IBaseFilter_EnumPins(detector->source, &enum_pins)))
 138     {
 139         ERR("Failed to enumerate source pins, hr %#x.\n", hr);
 140         return hr;
 141     }
 142     hr = IEnumPins_Next(enum_pins, 1, &source_pin, NULL);
 143     IEnumPins_Release(enum_pins);
 144     if (hr != S_OK)
 145     {
 146         ERR("Failed to get source pin, hr %#x.\n", hr);
 147         return hr;
 148     }
 149
 150     if (FAILED(hr = get_pin_media_type(source_pin, &mt)))
 151     {
 152         ERR("Failed to get media type, hr %#x.\n", hr);
 153         IPin_Release(source_pin);
 154         return hr;
 155     }
 156
 157     type[0] = mt.majortype;
 158     type[1] = mt.subtype;
 159     FreeMediaType(&mt);
 160
 161     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL,
 162             CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (void **)&mapper)))
 163     {
 164         IPin_Release(source_pin);
 165         return hr;
 166     }
 167
 168     hr = IFilterMapper2_EnumMatchingFilters(mapper, &enum_moniker, 0, TRUE,
 169             MERIT_UNLIKELY, FALSE, 1, type, NULL, NULL, FALSE, TRUE, 0, NULL, NULL, NULL);
 170     IFilterMapper2_Release(mapper);
 171     if (FAILED(hr))
 172     {
 173         IPin_Release(source_pin);
 174         return hr;
 175     }
 176
 177     hr = E_NOINTERFACE;
 178     while (IEnumMoniker_Next(enum_moniker, 1, &mon, NULL) == S_OK)
 179     {
 180         hr = get_filter_info(mon, &clsid, &var);
 181         IMoniker_Release(mon);
 182         if (FAILED(hr))
 183             continue;
 184
 185         hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER,
 186                 &IID_IBaseFilter, (void **)&splitter);
 187         if (FAILED(hr))
 188         {
 189             VariantClear(&var);
 190             continue;
 191         }
 192
 193         hr = IGraphBuilder_AddFilter(detector->graph, splitter, V_BSTR(&var));
 194         VariantClear(&var);
 195         if (FAILED(hr))
 196         {
 197             IBaseFilter_Release(splitter);
 198             continue;
 199         }
 200
 201         hr = IBaseFilter_EnumPins(splitter, &enum_pins);
 202         if (FAILED(hr))
 203             goto next;
 204
 205         hr = IEnumPins_Next(enum_pins, 1, &splitter_pin, NULL);
 206         IEnumPins_Release(enum_pins);
 207         if (hr != S_OK)
 208             goto next;
 209
 210         hr = IPin_Connect(source_pin, splitter_pin, NULL);
 211         IPin_Release(splitter_pin);
 212         if (SUCCEEDED(hr))
 213         {
 214             detector->splitter = splitter;
 215             break;
 216         }
 217
 218 next:
 219         IGraphBuilder_RemoveFilter(detector->graph, splitter);
 220         IBaseFilter_Release(splitter);
 221     }
 222
 223     IEnumMoniker_Release(enum_moniker);
 224     IPin_Release(source_pin);
 225     return hr;
 226 }
 227
 228 /* MediaDet inner IUnknown */
 229 static HRESULT WINAPI MediaDet_inner_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 230 {
 231     MediaDetImpl *This = impl_from_IUnknown(iface);
 232
 233     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 234
 235     *ppv = NULL;
 236     if (IsEqualIID(riid, &IID_IUnknown))
 237         *ppv = &This->IUnknown_inner;
 238     else if (IsEqualIID(riid, &IID_IMediaDet))
 239         *ppv = &This->IMediaDet_iface;
 240     else
 241         WARN("(%p, %s,%p): not found\n", This, debugstr_guid(riid), ppv);
 242
 243     if (!*ppv)
 244         return E_NOINTERFACE;
 245
 246     IUnknown_AddRef((IUnknown*)*ppv);
 247     return S_OK;
 248 }
 249
 250 static ULONG WINAPI MediaDet_inner_AddRef(IUnknown *iface)
 251 {
 252     MediaDetImpl *This = impl_from_IUnknown(iface);
 253     ULONG ref = InterlockedIncrement(&This->ref);
 254
 255     TRACE("(%p) new ref = %u\n", This, ref);
 256
 257     return ref;
 258 }
 259
 260 static ULONG WINAPI MediaDet_inner_Release(IUnknown *iface)
 261 {
 262     MediaDetImpl *This = impl_from_IUnknown(iface);
 263     ULONG ref = InterlockedDecrement(&This->ref);
 264
 265     TRACE("(%p) new ref = %u\n", This, ref);
 266
 267     if (ref == 0)
 268     {
 269         MD_cleanup(This);
 270         CoTaskMemFree(This);
 271     }
 272
 273     return ref;
 274 }
 275
 276 static const IUnknownVtbl mediadet_vtbl =
 277 {
 278     MediaDet_inner_QueryInterface,
 279     MediaDet_inner_AddRef,
 280     MediaDet_inner_Release,
 281 };
 282
 283 /* IMediaDet implementation */
 284 static HRESULT WINAPI MediaDet_QueryInterface(IMediaDet *iface, REFIID riid, void **ppv)
 285 {
 286     MediaDetImpl *This = impl_from_IMediaDet(iface);
 287     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 288 }
 289
 290 static ULONG WINAPI MediaDet_AddRef(IMediaDet *iface)
 291 {
 292     MediaDetImpl *This = impl_from_IMediaDet(iface);
 293     return IUnknown_AddRef(This->outer_unk);
 294 }
 295
 296 static ULONG WINAPI MediaDet_Release(IMediaDet *iface)
 297 {
 298     MediaDetImpl *This = impl_from_IMediaDet(iface);
 299     return IUnknown_Release(This->outer_unk);
 300 }
 301
 302 static HRESULT WINAPI MediaDet_get_Filter(IMediaDet *iface, IUnknown **filter)
 303 {
 304     MediaDetImpl *detector = impl_from_IMediaDet(iface);
 305
 306     TRACE("detector %p, filter %p.\n", detector, filter);
 307
 308     if (!filter)
 309         return E_POINTER;
 310
 311     *filter = (IUnknown *)detector->source;
 312     if (*filter)
 313         IUnknown_AddRef(*filter);
 314     else
 315         return S_FALSE;
 316
 317     return S_OK;
 318 }
 319
 320 static HRESULT WINAPI MediaDet_put_Filter(IMediaDet *iface, IUnknown *unk)
 321 {
 322     MediaDetImpl *detector = impl_from_IMediaDet(iface);
 323     IGraphBuilder *graph;
 324     IBaseFilter *filter;
 325     HRESULT hr;
 326
 327     TRACE("detector %p, unk %p.\n", detector, unk);
 328
 329     if (!unk)
 330         return E_POINTER;
 331
 332     if (FAILED(hr = IUnknown_QueryInterface(unk, &IID_IBaseFilter, (void **)&filter)))
 333     {
 334         WARN("Object does not expose IBaseFilter.\n");
 335         return hr;
 336     }
 337
 338     if (detector->graph)
 339         MD_cleanup(detector);
 340
 341     if (FAILED(hr = CoCreateInstance(&CLSID_FilterGraph, NULL,
 342             CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (void **)&graph)))
 343     {
 344         IBaseFilter_Release(filter);
 345         return hr;
 346     }
 347
 348     if (FAILED(hr = IGraphBuilder_AddFilter(graph, filter, L"Source")))
 349     {
 350         IGraphBuilder_Release(graph);
 351         IBaseFilter_Release(filter);
 352         return hr;
 353     }
 354
 355     detector->graph = graph;
 356     detector->source = filter;
 357     if (FAILED(find_splitter(detector)))
 358     {
 359         detector->splitter = detector->source;
 360         IBaseFilter_AddRef(detector->splitter);
 361     }
 362
 363     return IMediaDet_put_CurrentStream(&detector->IMediaDet_iface, 0);
 364 }
 365
 366 static HRESULT WINAPI MediaDet_get_OutputStreams(IMediaDet* iface, LONG *pVal)
 367 {
 368     MediaDetImpl *This = impl_from_IMediaDet(iface);
 369     IEnumPins *pins;
 370     IPin *pin;
 371     HRESULT hr;
 372
 373     TRACE("(%p)\n", This);
 374
 375     if (!This->splitter)
 376         return E_INVALIDARG;
 377
 378     if (This->num_streams != -1)
 379     {
 380         *pVal = This->num_streams;
 381         return S_OK;
 382     }
 383
 384     *pVal = 0;
 385
 386     hr = IBaseFilter_EnumPins(This->splitter, &pins);
 387     if (FAILED(hr))
 388         return hr;
 389
 390     while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK)
 391     {
 392         PIN_DIRECTION dir;
 393         hr = IPin_QueryDirection(pin, &dir);
 394         IPin_Release(pin);
 395         if (FAILED(hr))
 396         {
 397             IEnumPins_Release(pins);
 398             return hr;
 399         }
 400
 401         if (dir == PINDIR_OUTPUT)
 402             ++*pVal;
 403     }
 404     IEnumPins_Release(pins);
 405
 406     This->num_streams = *pVal;
 407     return S_OK;
 408 }
 409
 410 static HRESULT WINAPI MediaDet_get_CurrentStream(IMediaDet* iface, LONG *pVal)
 411 {
 412     MediaDetImpl *This = impl_from_IMediaDet(iface);
 413     TRACE("(%p)\n", This);
 414
 415     if (!pVal)
 416         return E_POINTER;
 417
 418     *pVal = This->cur_stream;
 419     return S_OK;
 420 }
 421
 422 static HRESULT SetCurPin(MediaDetImpl *This, LONG strm)
 423 {
 424     IEnumPins *pins;
 425     IPin *pin;
 426     HRESULT hr;
 427
 428     assert(This->splitter);
 429     assert(0 <= strm && strm < This->num_streams);
 430
 431     if (This->cur_pin)
 432     {
 433         IPin_Release(This->cur_pin);
 434         This->cur_pin = NULL;
 435     }
 436
 437     hr = IBaseFilter_EnumPins(This->splitter, &pins);
 438     if (FAILED(hr))
 439         return hr;
 440
 441     while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !This->cur_pin)
 442     {
 443         PIN_DIRECTION dir;
 444         hr = IPin_QueryDirection(pin, &dir);
 445         if (FAILED(hr))
 446         {
 447             IPin_Release(pin);
 448             IEnumPins_Release(pins);
 449             return hr;
 450         }
 451
 452         if (dir == PINDIR_OUTPUT && strm-- == 0)
 453             This->cur_pin = pin;
 454         else
 455             IPin_Release(pin);
 456     }
 457     IEnumPins_Release(pins);
 458
 459     assert(This->cur_pin);
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI MediaDet_put_CurrentStream(IMediaDet* iface, LONG newVal)
 464 {
 465     MediaDetImpl *This = impl_from_IMediaDet(iface);
 466     HRESULT hr;
 467
 468     TRACE("(%p)->(%d)\n", This, newVal);
 469
 470     if (This->num_streams == -1)
 471     {
 472         LONG n;
 473         hr = MediaDet_get_OutputStreams(iface, &n);
 474         if (FAILED(hr))
 475             return hr;
 476     }
 477
 478     if (newVal < 0 || This->num_streams <= newVal)
 479         return E_INVALIDARG;
 480
 481     hr = SetCurPin(This, newVal);
 482     if (FAILED(hr))
 483         return hr;
 484
 485     This->cur_stream = newVal;
 486     return S_OK;
 487 }
 488
 489 static HRESULT WINAPI MediaDet_get_StreamType(IMediaDet *iface, GUID *majortype)
 490 {
 491     MediaDetImpl *detector = impl_from_IMediaDet(iface);
 492     AM_MEDIA_TYPE mt;
 493     HRESULT hr;
 494
 495     TRACE("detector %p, majortype %p.\n", detector, majortype);
 496
 497     if (!majortype)
 498         return E_POINTER;
 499
 500     if (SUCCEEDED(hr = IMediaDet_get_StreamMediaType(iface, &mt)))
 501     {
 502         *majortype = mt.majortype;
 503         FreeMediaType(&mt);
 504     }
 505
 506     return hr;
 507 }
 508
 509 static HRESULT WINAPI MediaDet_get_StreamTypeB(IMediaDet *iface, BSTR *bstr)
 510 {
 511     MediaDetImpl *detector = impl_from_IMediaDet(iface);
 512     HRESULT hr;
 513     GUID guid;
 514
 515     TRACE("detector %p, bstr %p.\n", detector, bstr);
 516
 517     if (SUCCEEDED(hr = IMediaDet_get_StreamType(iface, &guid)))
 518     {
 519         if (!(*bstr = SysAllocStringLen(NULL, CHARS_IN_GUID - 1)))
 520             return E_OUTOFMEMORY;
 521         StringFromGUID2(&guid, *bstr, CHARS_IN_GUID);
 522     }
 523     return hr;
 524 }
 525
 526 static HRESULT WINAPI MediaDet_get_StreamLength(IMediaDet *iface, double *length)
 527 {
 528     MediaDetImpl *detector = impl_from_IMediaDet(iface);
 529     IMediaSeeking *seeking;
 530     HRESULT hr;
 531
 532     TRACE("detector %p, length %p.\n", detector, length);
 533
 534     if (!length)
 535         return E_POINTER;
 536
 537     if (!detector->cur_pin)
 538         return E_INVALIDARG;
 539
 540     if (SUCCEEDED(hr = IPin_QueryInterface(detector->cur_pin,
 541                 &IID_IMediaSeeking, (void **)&seeking)))
 542     {
 543         LONGLONG duration;
 544
 545         if (SUCCEEDED(hr = IMediaSeeking_GetDuration(seeking, &duration)))
 546         {
 547             /* Windows assumes the time format is TIME_FORMAT_MEDIA_TIME
 548                and does not check it nor convert it, as tests show. */
 549             *length = (REFTIME)duration / 10000000;
 550         }
 551         IMediaSeeking_Release(seeking);
 552     }
 553
 554     return hr;
 555 }
 556
 557 static HRESULT WINAPI MediaDet_get_Filename(IMediaDet* iface, BSTR *pVal)
 558 {
 559     MediaDetImpl *This = impl_from_IMediaDet(iface);
 560
 561     TRACE("(%p)\n", This);
 562
 563     if (!pVal)
 564         return E_POINTER;
 565
 566     *pVal = NULL;
 567     /* MSDN says it should return E_FAIL if no file is open, but tests
 568        show otherwise.  */
 569     if (!This->filename)
 570         return S_OK;
 571
 572     *pVal = SysAllocString(This->filename);
 573     if (!*pVal)
 574         return E_OUTOFMEMORY;
 575
 576     return S_OK;
 577 }
 578
 579 static HRESULT WINAPI MediaDet_put_Filename(IMediaDet *iface, BSTR filename)
 580 {
 581     MediaDetImpl *This = impl_from_IMediaDet(iface);
 582     IGraphBuilder *gb;
 583     IBaseFilter *bf;
 584     HRESULT hr;
 585
 586     TRACE("detector %p, filename %s.\n", This, debugstr_w(filename));
 587
 588     if (This->graph)
 589     {
 590         WARN("MSDN says not to call this method twice\n");
 591         MD_cleanup(This);
 592     }
 593
 594     hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
 595                           &IID_IGraphBuilder, (void **) &gb);
 596     if (FAILED(hr))
 597         return hr;
 598
 599     if (FAILED(hr = IGraphBuilder_AddSourceFilter(gb, filename, L"Source", &bf)))
 600     {
 601         IGraphBuilder_Release(gb);
 602         return hr;
 603     }
 604
 605     if (!(This->filename = wcsdup(filename)))
 606     {
 607         IBaseFilter_Release(bf);
 608         IGraphBuilder_Release(gb);
 609         return E_OUTOFMEMORY;
 610     }
 611
 612     This->graph = gb;
 613     This->source = bf;
 614     hr = find_splitter(This);
 615     if (FAILED(hr))
 616         return hr;
 617
 618     return MediaDet_put_CurrentStream(iface, 0);
 619 }
 620
 621 static HRESULT WINAPI MediaDet_GetBitmapBits(IMediaDet* iface,
 622                                              double StreamTime,
 623                                              LONG *pBufferSize, char *pBuffer,
 624                                              LONG Width, LONG Height)
 625 {
 626     MediaDetImpl *This = impl_from_IMediaDet(iface);
 627     FIXME("(%p)->(%f %p %p %d %d): not implemented!\n", This, StreamTime, pBufferSize, pBuffer,
 628           Width, Height);
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI MediaDet_WriteBitmapBits(IMediaDet* iface,
 633                                                double StreamTime, LONG Width,
 634                                                LONG Height, BSTR Filename)
 635 {
 636     MediaDetImpl *This = impl_from_IMediaDet(iface);
 637     FIXME("(%p)->(%f %d %d %p): not implemented!\n", This, StreamTime, Width, Height, Filename);
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI MediaDet_get_StreamMediaType(IMediaDet* iface,
 642                                                    AM_MEDIA_TYPE *pVal)
 643 {
 644     MediaDetImpl *This = impl_from_IMediaDet(iface);
 645
 646     TRACE("(%p)\n", This);
 647
 648     if (!pVal)
 649         return E_POINTER;
 650
 651     if (!This->cur_pin)
 652         return E_INVALIDARG;
 653
 654     return get_pin_media_type(This->cur_pin, pVal);
 655 }
 656
 657 static HRESULT WINAPI MediaDet_GetSampleGrabber(IMediaDet* iface,
 658                                                 ISampleGrabber **ppVal)
 659 {
 660     MediaDetImpl *This = impl_from_IMediaDet(iface);
 661     FIXME("(%p)->(%p): not implemented!\n", This, ppVal);
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI MediaDet_get_FrameRate(IMediaDet* iface, double *pVal)
 666 {
 667     MediaDetImpl *This = impl_from_IMediaDet(iface);
 668     AM_MEDIA_TYPE mt;
 669     VIDEOINFOHEADER *vh;
 670     HRESULT hr;
 671
 672     TRACE("(%p)\n", This);
 673
 674     if (!pVal)
 675         return E_POINTER;
 676
 677     hr = MediaDet_get_StreamMediaType(iface, &mt);
 678     if (FAILED(hr))
 679         return hr;
 680
 681     if (!IsEqualGUID(&mt.majortype, &MEDIATYPE_Video))
 682     {
 683         CoTaskMemFree(mt.pbFormat);
 684         return VFW_E_INVALIDMEDIATYPE;
 685     }
 686
 687     vh = (VIDEOINFOHEADER *) mt.pbFormat;
 688     *pVal = 1.0e7 / (double) vh->AvgTimePerFrame;
 689
 690     CoTaskMemFree(mt.pbFormat);
 691     return S_OK;
 692 }
 693
 694 static HRESULT WINAPI MediaDet_EnterBitmapGrabMode(IMediaDet* iface,
 695                                                    double SeekTime)
 696 {
 697     MediaDetImpl *This = impl_from_IMediaDet(iface);
 698     FIXME("(%p)->(%f): not implemented!\n", This, SeekTime);
 699     return E_NOTIMPL;
 700 }
 701
 702 static const IMediaDetVtbl IMediaDet_VTable =
 703 {
 704     MediaDet_QueryInterface,
 705     MediaDet_AddRef,
 706     MediaDet_Release,
 707     MediaDet_get_Filter,
 708     MediaDet_put_Filter,
 709     MediaDet_get_OutputStreams,
 710     MediaDet_get_CurrentStream,
 711     MediaDet_put_CurrentStream,
 712     MediaDet_get_StreamType,
 713     MediaDet_get_StreamTypeB,
 714     MediaDet_get_StreamLength,
 715     MediaDet_get_Filename,
 716     MediaDet_put_Filename,
 717     MediaDet_GetBitmapBits,
 718     MediaDet_WriteBitmapBits,
 719     MediaDet_get_StreamMediaType,
 720     MediaDet_GetSampleGrabber,
 721     MediaDet_get_FrameRate,
 722     MediaDet_EnterBitmapGrabMode,
 723 };
 724
 725 HRESULT media_detector_create(IUnknown *pUnkOuter, IUnknown **ppv)
 726 {
 727     MediaDetImpl* obj = NULL;
 728
 729     TRACE("(%p,%p)\n", pUnkOuter, ppv);
 730
 731     obj = CoTaskMemAlloc(sizeof(MediaDetImpl));
 732     if (NULL == obj) {
 733         *ppv = NULL;
 734         return E_OUTOFMEMORY;
 735     }
 736     ZeroMemory(obj, sizeof(MediaDetImpl));
 737
 738     obj->ref = 1;
 739     obj->IUnknown_inner.lpVtbl = &mediadet_vtbl;
 740     obj->IMediaDet_iface.lpVtbl = &IMediaDet_VTable;
 741     obj->graph = NULL;
 742     obj->source = NULL;
 743     obj->splitter = NULL;
 744     obj->cur_pin = NULL;
 745     obj->num_streams = -1;
 746     obj->cur_stream = 0;
 747
 748     if (pUnkOuter)
 749         obj->outer_unk = pUnkOuter;
 750     else
 751         obj->outer_unk = &obj->IUnknown_inner;
 752
 753     *ppv = &obj->IUnknown_inner;
 754     return S_OK;
 755 }