dlls/qcap/tests/qcap.c

   1 /*
   2  *    QCAP tests
   3  *
   4  * Copyright 2013 Damjan Jovanovic
   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 <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #define COBJMACROS
  26 #include <dshow.h>
  27 #include <guiddef.h>
  28 #include <devguid.h>
  29 #include <stdio.h>
  30
  31 #include "wine/strmbase.h"
  32 #include "wine/test.h"
  33
  34 static const char *debugstr_guid(REFIID riid)
  35 {
  36     static char buf[50];
  37
  38     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  39             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  40             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  41             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  42
  43     return buf;
  44 }
  45
  46 static void test_smart_tee_filter(void)
  47 {
  48     HRESULT hr;
  49     IBaseFilter *smartTeeFilter = NULL;
  50     IEnumPins *enumPins = NULL;
  51     IPin *pin;
  52     FILTER_INFO filterInfo;
  53     int pinNumber = 0;
  54
  55     hr = CoCreateInstance(&CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER,
  56             &IID_IBaseFilter, (void**)&smartTeeFilter);
  57     todo_wine ok(SUCCEEDED(hr), "couldn't create smart tee filter, hr=%08x\n", hr);
  58     if (FAILED(hr))
  59         goto end;
  60
  61     hr = IBaseFilter_QueryFilterInfo(smartTeeFilter, &filterInfo);
  62     ok(SUCCEEDED(hr), "QueryFilterInfo failed, hr=%08x\n", hr);
  63     if (FAILED(hr))
  64         goto end;
  65
  66     ok(lstrlenW(filterInfo.achName) == 0,
  67             "filter's name is meant to be empty but it's %s\n", wine_dbgstr_w(filterInfo.achName));
  68
  69     hr = IBaseFilter_EnumPins(smartTeeFilter, &enumPins);
  70     ok(SUCCEEDED(hr), "cannot enum filter pins, hr=%08x\n", hr);
  71     if (FAILED(hr))
  72         goto end;
  73
  74     while (IEnumPins_Next(enumPins, 1, &pin, NULL) == S_OK)
  75     {
  76         PIN_INFO pinInfo;
  77         hr = IPin_QueryPinInfo(pin, &pinInfo);
  78         ok(SUCCEEDED(hr), "QueryPinInfo failed, hr=%08x\n", hr);
  79         if (FAILED(hr))
  80             goto endwhile;
  81
  82         if (pinNumber == 0)
  83         {
  84             static const WCHAR wszInput[] = {'I','n','p','u','t',0};
  85             ok(pinInfo.dir == PINDIR_INPUT, "pin 0 isn't an input pin\n");
  86             ok(!lstrcmpW(pinInfo.achName, wszInput), "pin 0 is called %s, not 'Input'\n", wine_dbgstr_w(pinInfo.achName));
  87         }
  88         else if (pinNumber == 1)
  89         {
  90             static const WCHAR wszCapture[] = {'C','a','p','t','u','r','e',0};
  91             ok(pinInfo.dir == PINDIR_OUTPUT, "pin 1 isn't an output pin\n");
  92             ok(!lstrcmpW(pinInfo.achName, wszCapture), "pin 1 is called %s, not 'Capture'\n", wine_dbgstr_w(pinInfo.achName));
  93         }
  94         else if (pinNumber == 2)
  95         {
  96             static const WCHAR wszPreview[] = {'P','r','e','v','i','e','w',0};
  97             ok(pinInfo.dir == PINDIR_OUTPUT, "pin 2 isn't an output pin\n");
  98             ok(!lstrcmpW(pinInfo.achName, wszPreview), "pin 2 is called %s, not 'Preview'\n", wine_dbgstr_w(pinInfo.achName));
  99         }
 100         else
 101             ok(0, "pin %d isn't supposed to exist\n", pinNumber);
 102
 103     endwhile:
 104         IPin_Release(pin);
 105         pinNumber++;
 106     }
 107
 108 end:
 109     if (smartTeeFilter)
 110         IBaseFilter_Release(smartTeeFilter);
 111     if (enumPins)
 112         IEnumPins_Release(enumPins);
 113 }
 114
 115 typedef enum {
 116     SOURCE_FILTER,
 117     SINK_FILTER,
 118     INTERMEDIATE_FILTER,
 119     NOT_FILTER
 120 } filter_type;
 121
 122 static const char* debugstr_filter_type(filter_type type)
 123 {
 124     switch(type) {
 125     case SOURCE_FILTER:
 126         return "SOURCE_FILTER";
 127     case SINK_FILTER:
 128         return "SINK_FILTER";
 129     case INTERMEDIATE_FILTER:
 130         return "INTERMEDIATE_FILTER";
 131     default:
 132         return "NOT_FILTER";
 133     }
 134 }
 135
 136 typedef enum {
 137     BASEFILTER_ENUMPINS,
 138     ENUMPINS_NEXT,
 139     PIN_QUERYDIRECTION,
 140     PIN_CONNECTEDTO,
 141     PIN_QUERYPININFO,
 142     KSPROPERTYSET_GET,
 143     PIN_ENUMMEDIATYPES,
 144     ENUMMEDIATYPES_RESET,
 145     ENUMMEDIATYPES_NEXT,
 146     GRAPHBUILDER_CONNECT,
 147     BASEFILTER_GETSTATE,
 148     BASEFILTER_QUERYINTERFACE,
 149     END
 150 } call_id;
 151
 152 static const struct {
 153     call_id call_id;
 154     filter_type filter_type;
 155     BOOL wine_missing;
 156     BOOL wine_extra;
 157     BOOL optional; /* fails on wine if missing */
 158     BOOL broken;
 159 } renderstream_cat_media[] = {
 160     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 161     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 162     {ENUMPINS_NEXT, SOURCE_FILTER},
 163     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 164     {PIN_CONNECTEDTO, SOURCE_FILTER},
 165     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 166     {KSPROPERTYSET_GET, SOURCE_FILTER},
 167     {PIN_ENUMMEDIATYPES, SOURCE_FILTER},
 168     {ENUMMEDIATYPES_RESET, SOURCE_FILTER},
 169     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER},
 170     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 171     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 172     {ENUMPINS_NEXT, SOURCE_FILTER},
 173     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 174     {PIN_CONNECTEDTO, SOURCE_FILTER},
 175     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 176     {KSPROPERTYSET_GET, SOURCE_FILTER},
 177     {ENUMPINS_NEXT, SOURCE_FILTER},
 178     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 179     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 180     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 181     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 182     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 183     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 184     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 185     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 186     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 187     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 188     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 189     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 190     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 191     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 192     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 193     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 194     {PIN_ENUMMEDIATYPES, SOURCE_FILTER, TRUE, FALSE, TRUE},
 195     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER, TRUE, FALSE, TRUE},
 196     {BASEFILTER_QUERYINTERFACE, SINK_FILTER, FALSE, TRUE},
 197     {BASEFILTER_ENUMPINS, SINK_FILTER},
 198     {ENUMPINS_NEXT, SINK_FILTER},
 199     {PIN_QUERYDIRECTION, SINK_FILTER},
 200     {PIN_CONNECTEDTO, SINK_FILTER},
 201     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 202     {BASEFILTER_GETSTATE, SOURCE_FILTER, TRUE, FALSE, TRUE},
 203     {BASEFILTER_ENUMPINS, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 204     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 205     {PIN_QUERYDIRECTION, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 206     {PIN_CONNECTEDTO, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 207     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 208     {END, NOT_FILTER}
 209 }, renderstream_intermediate[] = {
 210     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 211     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 212     {ENUMPINS_NEXT, SOURCE_FILTER},
 213     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 214     {PIN_CONNECTEDTO, SOURCE_FILTER},
 215     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 216     {KSPROPERTYSET_GET, SOURCE_FILTER},
 217     {PIN_ENUMMEDIATYPES, SOURCE_FILTER},
 218     {ENUMMEDIATYPES_RESET, SOURCE_FILTER},
 219     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER},
 220     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 221     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 222     {ENUMPINS_NEXT, SOURCE_FILTER},
 223     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 224     {PIN_CONNECTEDTO, SOURCE_FILTER},
 225     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 226     {KSPROPERTYSET_GET, SOURCE_FILTER},
 227     {ENUMPINS_NEXT, SOURCE_FILTER},
 228     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 229     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 230     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 231     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 232     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 233     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 234     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 235     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 236     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 237     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 238     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 239     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 240     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 241     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 242     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 243     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 244     {PIN_ENUMMEDIATYPES, SOURCE_FILTER, TRUE, FALSE, TRUE},
 245     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER, TRUE, FALSE, TRUE},
 246     {BASEFILTER_QUERYINTERFACE, SINK_FILTER, FALSE, TRUE},
 247     {BASEFILTER_ENUMPINS, SINK_FILTER},
 248     {ENUMPINS_NEXT, SINK_FILTER},
 249     {PIN_QUERYDIRECTION, SINK_FILTER},
 250     {PIN_CONNECTEDTO, SINK_FILTER},
 251     {BASEFILTER_QUERYINTERFACE, INTERMEDIATE_FILTER, FALSE, TRUE},
 252     {BASEFILTER_ENUMPINS, INTERMEDIATE_FILTER},
 253     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 254     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 255     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 256     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 257     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 258     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 259     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 260     {BASEFILTER_QUERYINTERFACE, INTERMEDIATE_FILTER, FALSE, TRUE},
 261     {BASEFILTER_ENUMPINS, INTERMEDIATE_FILTER},
 262     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 263     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 264     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 265     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 266     {BASEFILTER_GETSTATE, SOURCE_FILTER, TRUE, FALSE, TRUE},
 267     {BASEFILTER_ENUMPINS, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 268     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 269     {PIN_QUERYDIRECTION, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 270     {PIN_CONNECTEDTO, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 271     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 272     {END, NOT_FILTER}
 273 }, *current_calls_list;
 274 int call_no;
 275
 276 static void check_calls_list(const char *func, call_id id, filter_type type)
 277 {
 278     if(!current_calls_list)
 279         return;
 280
 281     while(current_calls_list[call_no].wine_missing || current_calls_list[call_no].wine_extra ||
 282          current_calls_list[call_no].optional || current_calls_list[call_no].broken) {
 283         if(current_calls_list[call_no].wine_missing) {
 284             todo_wine ok((current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 285                     broken(current_calls_list[call_no].optional && (current_calls_list[call_no].call_id != id ||
 286                             current_calls_list[call_no].filter_type != type)),
 287                     "missing call, got %s(%d), expected %d (%d)\n", func, id, current_calls_list[call_no].call_id, call_no);
 288
 289             if(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type)
 290                 call_no++;
 291             else
 292                 break;
 293         }else if(current_calls_list[call_no].wine_extra) {
 294             todo_wine ok(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type,
 295                     "extra call, got %s(%d) (%d)\n", func, id, call_no);
 296
 297             if(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) {
 298                 call_no++;
 299                 return;
 300             }
 301             call_no++;
 302         }else if(current_calls_list[call_no].optional) {
 303             ok((current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 304                     broken(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type),
 305                     "unexpected call: %s on %s (%d)\n", func, debugstr_filter_type(type), call_no);
 306
 307             if(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type)
 308                 call_no++;
 309             else
 310                 break;
 311         }else if(current_calls_list[call_no].broken) {
 312             ok(broken(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 313                     (current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type),
 314                     "unexpected call: %s on %s (%d)\n", func, debugstr_filter_type(type), call_no);
 315
 316             if(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type)
 317                 break;
 318             call_no++;
 319         }
 320     }
 321
 322     ok(current_calls_list[call_no].call_id == id, "unexpected call: %s on %s (%d)\n",
 323             func, debugstr_filter_type(type), call_no);
 324     if(current_calls_list[call_no].call_id != id)
 325         return;
 326
 327     ok(current_calls_list[call_no].filter_type == type, "unexpected call: %s on %s (%d)\n",
 328             func, debugstr_filter_type(type), call_no);
 329     if(current_calls_list[call_no].filter_type != type)
 330         return;
 331
 332     call_no++;
 333 }
 334
 335 static HRESULT WINAPI GraphBuilder_QueryInterface(
 336         IGraphBuilder *iface, REFIID riid, void **ppv)
 337 {
 338     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IFilterGraph)
 339             || IsEqualIID(riid, &IID_IGraphBuilder))
 340     {
 341         *ppv = iface;
 342         return S_OK;
 343     }
 344
 345     ok(IsEqualIID(riid, &IID_IMediaEvent), "QueryInterface(%s)\n", debugstr_guid(riid));
 346     *ppv = NULL;
 347     return E_NOINTERFACE;
 348 }
 349
 350 static ULONG WINAPI GraphBuilder_AddRef(IGraphBuilder *iface)
 351 {
 352     return 2;
 353 }
 354
 355 static ULONG WINAPI GraphBuilder_Release(IGraphBuilder *iface)
 356 {
 357     return 1;
 358 }
 359
 360 static HRESULT WINAPI GraphBuilder_AddFilter(IGraphBuilder *iface,
 361         IBaseFilter *pFilter, LPCWSTR pName)
 362 {
 363     ok(0, "unexpected call\n");
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI GraphBuilder_RemoveFilter(
 368         IGraphBuilder *iface, IBaseFilter *pFilter)
 369 {
 370     ok(0, "unexpected call\n");
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI GraphBuilder_EnumFilters(
 375         IGraphBuilder *iface, IEnumFilters **ppEnum)
 376 {
 377     ok(0, "unexpected call\n");
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI GraphBuilder_FindFilterByName(IGraphBuilder *iface,
 382         LPCWSTR pName, IBaseFilter **ppFilter)
 383 {
 384     ok(0, "unexpected call\n");
 385     return E_NOTIMPL;
 386 }
 387
 388 static HRESULT WINAPI GraphBuilder_ConnectDirect(IGraphBuilder *iface,
 389         IPin *ppinOut, IPin *ppinIn, const AM_MEDIA_TYPE *pmt)
 390 {
 391     ok(0, "unexpected call\n");
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI GraphBuilder_Reconnect(IGraphBuilder *iface, IPin *ppin)
 396 {
 397     ok(0, "unexpected call\n");
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI GraphBuilder_Disconnect(IGraphBuilder *iface, IPin *ppin)
 402 {
 403     ok(0, "unexpected call\n");
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI GraphBuilder_SetDefaultSyncSource(IGraphBuilder *iface)
 408 {
 409     ok(0, "unexpected call\n");
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI GraphBuilder_Connect(IGraphBuilder *iface, IPin *ppinOut, IPin *ppinIn)
 414 {
 415     check_calls_list("GraphBuilder_Connect", GRAPHBUILDER_CONNECT, NOT_FILTER);
 416     return S_OK;
 417 }
 418
 419 static HRESULT WINAPI GraphBuilder_Render(IGraphBuilder *iface, IPin *ppinOut)
 420 {
 421     ok(0, "unexpected call\n");
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI GraphBuilder_RenderFile(IGraphBuilder *iface,
 426         LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
 427 {
 428     ok(0, "unexpected call\n");
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI GraphBuilder_AddSourceFilter(IGraphBuilder *iface, LPCWSTR lpcwstrFileName,
 433         LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
 434 {
 435     ok(0, "unexpected call\n");
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI GraphBuilder_SetLogFile(IGraphBuilder *iface, DWORD_PTR hFile)
 440 {
 441     ok(0, "unexpected call\n");
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI GraphBuilder_Abort(IGraphBuilder *iface)
 446 {
 447     ok(0, "unexpected call\n");
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI GraphBuilder_ShouldOperationContinue(IGraphBuilder *iface)
 452 {
 453     ok(0, "unexpected call\n");
 454     return E_NOTIMPL;
 455 }
 456
 457 static const IGraphBuilderVtbl GraphBuilder_vtbl = {
 458     GraphBuilder_QueryInterface,
 459     GraphBuilder_AddRef,
 460     GraphBuilder_Release,
 461     GraphBuilder_AddFilter,
 462     GraphBuilder_RemoveFilter,
 463     GraphBuilder_EnumFilters,
 464     GraphBuilder_FindFilterByName,
 465     GraphBuilder_ConnectDirect,
 466     GraphBuilder_Reconnect,
 467     GraphBuilder_Disconnect,
 468     GraphBuilder_SetDefaultSyncSource,
 469     GraphBuilder_Connect,
 470     GraphBuilder_Render,
 471     GraphBuilder_RenderFile,
 472     GraphBuilder_AddSourceFilter,
 473     GraphBuilder_SetLogFile,
 474     GraphBuilder_Abort,
 475     GraphBuilder_ShouldOperationContinue
 476 };
 477
 478 static IGraphBuilder GraphBuilder = {&GraphBuilder_vtbl};
 479
 480 typedef struct {
 481     IBaseFilter IBaseFilter_iface;
 482     IEnumPins IEnumPins_iface;
 483     IPin IPin_iface;
 484     IKsPropertySet IKsPropertySet_iface;
 485     IEnumMediaTypes IEnumMediaTypes_iface;
 486
 487     PIN_DIRECTION dir;
 488     filter_type filter_type;
 489
 490     int enum_pins_pos;
 491     int enum_media_types_pos;
 492 } test_filter;
 493
 494 static test_filter* impl_from_IBaseFilter(IBaseFilter *iface)
 495 {
 496     return CONTAINING_RECORD(iface, test_filter, IBaseFilter_iface);
 497 }
 498
 499 static HRESULT WINAPI BaseFilter_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv)
 500 {
 501     test_filter *This = impl_from_IBaseFilter(iface);
 502
 503     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPersist)
 504             || IsEqualIID(riid, &IID_IMediaFilter) || IsEqualIID(riid, &IID_IBaseFilter)) {
 505         *ppv = iface;
 506         return S_OK;
 507     }
 508
 509     check_calls_list("BaseFilter_QueryInterface", BASEFILTER_QUERYINTERFACE, This->filter_type);
 510     ok(IsEqualIID(riid, &IID_IPin), "riid = %s\n", debugstr_guid(riid));
 511     return E_NOINTERFACE;
 512 }
 513
 514 static ULONG WINAPI BaseFilter_AddRef(IBaseFilter *iface)
 515 {
 516     return 2;
 517 }
 518
 519 static ULONG WINAPI BaseFilter_Release(IBaseFilter *iface)
 520 {
 521     return 1;
 522 }
 523
 524 static HRESULT WINAPI BaseFilter_GetClassID(IBaseFilter *iface, CLSID *pClassID)
 525 {
 526     ok(0, "unexpected call\n");
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI BaseFilter_Stop(IBaseFilter *iface)
 531 {
 532     ok(0, "unexpected call\n");
 533     return E_NOTIMPL;
 534 }
 535
 536 static HRESULT WINAPI BaseFilter_Pause(IBaseFilter *iface)
 537 {
 538     ok(0, "unexpected call\n");
 539     return E_NOTIMPL;
 540 }
 541
 542 static HRESULT WINAPI BaseFilter_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
 543 {
 544     ok(0, "unexpected call\n");
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI BaseFilter_GetState(IBaseFilter *iface,
 549         DWORD dwMilliSecsTimeout, FILTER_STATE *State)
 550 {
 551     test_filter *This = impl_from_IBaseFilter(iface);
 552     check_calls_list("BaseFilter_GetState", BASEFILTER_GETSTATE, This->filter_type);
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI BaseFilter_SetSyncSource(
 557         IBaseFilter *iface, IReferenceClock *pClock)
 558 {
 559     ok(0, "unexpected call\n");
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT WINAPI BaseFilter_GetSyncSource(
 564         IBaseFilter *iface, IReferenceClock **pClock)
 565 {
 566     ok(0, "unexpected call\n");
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI BaseFilter_EnumPins(
 571         IBaseFilter *iface, IEnumPins **ppEnum)
 572 {
 573     test_filter *This = impl_from_IBaseFilter(iface);
 574     check_calls_list("BaseFilter_EnumPins", BASEFILTER_ENUMPINS, This->filter_type);
 575
 576     *ppEnum = &This->IEnumPins_iface;
 577     This->enum_pins_pos = 0;
 578     return S_OK;
 579 }
 580
 581 static HRESULT WINAPI BaseFilter_FindPin(IBaseFilter *iface,
 582         LPCWSTR Id, IPin **ppPin)
 583 {
 584     ok(0, "unexpected call\n");
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI BaseFilter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo)
 589 {
 590     ok(0, "unexpected call\n");
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI BaseFilter_JoinFilterGraph(IBaseFilter *iface,
 595         IFilterGraph *pGraph, LPCWSTR pName)
 596 {
 597     ok(0, "unexpected call\n");
 598     return E_NOTIMPL;
 599 }
 600
 601 static HRESULT WINAPI BaseFilter_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo)
 602 {
 603     ok(0, "unexpected call\n");
 604     return E_NOTIMPL;
 605 }
 606
 607 static const IBaseFilterVtbl BaseFilterVtbl = {
 608     BaseFilter_QueryInterface,
 609     BaseFilter_AddRef,
 610     BaseFilter_Release,
 611     BaseFilter_GetClassID,
 612     BaseFilter_Stop,
 613     BaseFilter_Pause,
 614     BaseFilter_Run,
 615     BaseFilter_GetState,
 616     BaseFilter_SetSyncSource,
 617     BaseFilter_GetSyncSource,
 618     BaseFilter_EnumPins,
 619     BaseFilter_FindPin,
 620     BaseFilter_QueryFilterInfo,
 621     BaseFilter_JoinFilterGraph,
 622     BaseFilter_QueryVendorInfo
 623 };
 624
 625 static test_filter* impl_from_IEnumPins(IEnumPins *iface)
 626 {
 627     return CONTAINING_RECORD(iface, test_filter, IEnumPins_iface);
 628 }
 629
 630 static HRESULT WINAPI EnumPins_QueryInterface(IEnumPins *iface, REFIID riid, void **ppv)
 631 {
 632     ok(0, "unexpected call\n");
 633     return E_NOTIMPL;
 634 }
 635
 636 static ULONG WINAPI EnumPins_AddRef(IEnumPins *iface)
 637 {
 638     return 2;
 639 }
 640
 641 static ULONG WINAPI EnumPins_Release(IEnumPins *iface)
 642 {
 643     return 1;
 644 }
 645
 646 static HRESULT WINAPI EnumPins_Next(IEnumPins *iface,
 647         ULONG cPins, IPin **ppPins, ULONG *pcFetched)
 648 {
 649     test_filter *This = impl_from_IEnumPins(iface);
 650     check_calls_list("EnumPins_Next", ENUMPINS_NEXT, This->filter_type);
 651
 652     ok(cPins == 1, "cPins = %d\n", cPins);
 653     ok(ppPins != NULL, "ppPins == NULL\n");
 654     ok(pcFetched != NULL, "pcFetched == NULL\n");
 655
 656     if(This->enum_pins_pos++ < (This->filter_type == INTERMEDIATE_FILTER ? 2 : 1)) {
 657         *ppPins = &This->IPin_iface;
 658         *pcFetched = 1;
 659         return S_OK;
 660     }
 661     *pcFetched = 0;
 662     return S_FALSE;
 663 }
 664
 665 static HRESULT WINAPI EnumPins_Skip(IEnumPins *iface, ULONG cPins)
 666 {
 667     ok(0, "unexpected call\n");
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI EnumPins_Reset(IEnumPins *iface)
 672 {
 673     ok(0, "unexpected call\n");
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT WINAPI EnumPins_Clone(IEnumPins *iface, IEnumPins **ppEnum)
 678 {
 679     ok(0, "unexpected call\n");
 680     return E_NOTIMPL;
 681 }
 682
 683 static const IEnumPinsVtbl EnumPinsVtbl = {
 684     EnumPins_QueryInterface,
 685     EnumPins_AddRef,
 686     EnumPins_Release,
 687     EnumPins_Next,
 688     EnumPins_Skip,
 689     EnumPins_Reset,
 690     EnumPins_Clone
 691 };
 692
 693 static test_filter* impl_from_IPin(IPin *iface)
 694 {
 695     return CONTAINING_RECORD(iface, test_filter, IPin_iface);
 696 }
 697
 698 static HRESULT WINAPI Pin_QueryInterface(IPin *iface, REFIID riid, void **ppv)
 699 {
 700     test_filter *This = impl_from_IPin(iface);
 701
 702     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPin)) {
 703         *ppv = iface;
 704         return S_OK;
 705     }
 706
 707     if(IsEqualIID(riid, &IID_IKsPropertySet)) {
 708         *ppv = &This->IKsPropertySet_iface;
 709         return S_OK;
 710     }
 711
 712     ok(0, "unexpected call\n");
 713     *ppv = NULL;
 714     return E_NOINTERFACE;
 715 }
 716
 717 static ULONG WINAPI Pin_AddRef(IPin *iface)
 718 {
 719     return 2;
 720 }
 721
 722 static ULONG WINAPI Pin_Release(IPin *iface)
 723 {
 724     return 1;
 725 }
 726
 727 static HRESULT WINAPI Pin_Connect(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 728 {
 729     ok(0, "unexpected call\n");
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI Pin_ReceiveConnection(IPin *iface,
 734         IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 735 {
 736     ok(0, "unexpected call\n");
 737     return E_NOTIMPL;
 738 }
 739
 740 static HRESULT WINAPI Pin_Disconnect(IPin *iface)
 741 {
 742     ok(0, "unexpected call\n");
 743     return E_NOTIMPL;
 744 }
 745
 746 static HRESULT WINAPI Pin_ConnectedTo(IPin *iface, IPin **pPin)
 747 {
 748     test_filter *This = impl_from_IPin(iface);
 749     check_calls_list("Pin_ConnectedTo", PIN_CONNECTEDTO, This->filter_type);
 750
 751     *pPin = NULL;
 752     return S_OK;
 753 }
 754
 755 static HRESULT WINAPI Pin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *pmt)
 756 {
 757     ok(0, "unexpected call\n");
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI Pin_QueryPinInfo(IPin *iface, PIN_INFO *pInfo)
 762 {
 763     test_filter *This = impl_from_IPin(iface);
 764     check_calls_list("Pin_QueryPinInfo", PIN_QUERYPININFO, This->filter_type);
 765     return E_NOTIMPL;
 766 }
 767
 768 static HRESULT WINAPI Pin_QueryDirection(IPin *iface, PIN_DIRECTION *pPinDir)
 769 {
 770     test_filter *This = impl_from_IPin(iface);
 771     check_calls_list("Pin_QueryDirection", PIN_QUERYDIRECTION, This->filter_type);
 772
 773     *pPinDir = This->dir;
 774     if(This->filter_type==INTERMEDIATE_FILTER && This->enum_pins_pos==2)
 775         *pPinDir = PINDIR_INPUT;
 776     return S_OK;
 777 }
 778
 779 static HRESULT WINAPI Pin_QueryId(IPin *iface, LPWSTR *Id)
 780 {
 781     ok(0, "unexpected call\n");
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI Pin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt)
 786 {
 787     ok(0, "unexpected call\n");
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI Pin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum)
 792 {
 793     test_filter *This = impl_from_IPin(iface);
 794     check_calls_list("Pin_EnumMediaTypes", PIN_ENUMMEDIATYPES, This->filter_type);
 795
 796     ok(ppEnum != NULL, "ppEnum == NULL\n");
 797     *ppEnum = &This->IEnumMediaTypes_iface;
 798     return S_OK;
 799 }
 800
 801 static HRESULT WINAPI Pin_QueryInternalConnections(IPin *iface, IPin **apPin, ULONG *nPin)
 802 {
 803     ok(0, "unexpected call\n");
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI Pin_EndOfStream(IPin *iface)
 808 {
 809     ok(0, "unexpected call\n");
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI Pin_BeginFlush(IPin *iface)
 814 {
 815     ok(0, "unexpected call\n");
 816     return E_NOTIMPL;
 817 }
 818
 819 static HRESULT WINAPI Pin_EndFlush(IPin *iface)
 820 {
 821     ok(0, "unexpected call\n");
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI Pin_NewSegment(IPin *iface, REFERENCE_TIME tStart,
 826         REFERENCE_TIME tStop, double dRate)
 827 {
 828     ok(0, "unexpected call\n");
 829     return E_NOTIMPL;
 830 }
 831
 832 static const IPinVtbl PinVtbl = {
 833     Pin_QueryInterface,
 834     Pin_AddRef,
 835     Pin_Release,
 836     Pin_Connect,
 837     Pin_ReceiveConnection,
 838     Pin_Disconnect,
 839     Pin_ConnectedTo,
 840     Pin_ConnectionMediaType,
 841     Pin_QueryPinInfo,
 842     Pin_QueryDirection,
 843     Pin_QueryId,
 844     Pin_QueryAccept,
 845     Pin_EnumMediaTypes,
 846     Pin_QueryInternalConnections,
 847     Pin_EndOfStream,
 848     Pin_BeginFlush,
 849     Pin_EndFlush,
 850     Pin_NewSegment
 851 };
 852
 853 static test_filter* impl_from_IKsPropertySet(IKsPropertySet *iface)
 854 {
 855     return CONTAINING_RECORD(iface, test_filter, IKsPropertySet_iface);
 856 }
 857
 858 static HRESULT WINAPI KsPropertySet_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
 859 {
 860     ok(0, "unexpected call\n");
 861     return E_NOTIMPL;
 862 }
 863
 864 static ULONG WINAPI KsPropertySet_AddRef(IKsPropertySet *iface)
 865 {
 866     return 2;
 867 }
 868
 869 static ULONG WINAPI KsPropertySet_Release(IKsPropertySet *iface)
 870 {
 871     return 1;
 872 }
 873
 874 static HRESULT WINAPI KsPropertySet_Set(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID,
 875         LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData)
 876 {
 877     ok(0, "unexpected call\n");
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI KsPropertySet_Get(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID,
 882         LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned)
 883 {
 884     test_filter *This = impl_from_IKsPropertySet(iface);
 885     check_calls_list("KsPropertySet_Get", KSPROPERTYSET_GET, This->filter_type);
 886
 887     ok(IsEqualIID(guidPropSet, &AMPROPSETID_Pin), "guidPropSet = %s\n", debugstr_guid(guidPropSet));
 888     ok(dwPropID == 0, "dwPropID = %d\n", dwPropID);
 889     ok(pInstanceData == NULL, "pInstanceData != NULL\n");
 890     ok(cbInstanceData == 0, "cbInstanceData != 0\n");
 891     ok(cbPropData == sizeof(GUID), "cbPropData = %d\n", cbPropData);
 892     *pcbReturned = sizeof(GUID);
 893     memcpy(pPropData, &PIN_CATEGORY_EDS, sizeof(GUID));
 894     return S_OK;
 895 }
 896
 897 static HRESULT WINAPI KsPropertySet_QuerySupported(IKsPropertySet *iface,
 898         REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport)
 899 {
 900     ok(0, "unexpected call\n");
 901     return E_NOTIMPL;
 902 }
 903
 904 static const IKsPropertySetVtbl KsPropertySetVtbl = {
 905     KsPropertySet_QueryInterface,
 906     KsPropertySet_AddRef,
 907     KsPropertySet_Release,
 908     KsPropertySet_Set,
 909     KsPropertySet_Get,
 910     KsPropertySet_QuerySupported
 911 };
 912
 913 static test_filter* impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
 914 {
 915     return CONTAINING_RECORD(iface, test_filter, IEnumMediaTypes_iface);
 916 }
 917
 918 static HRESULT WINAPI EnumMediaTypes_QueryInterface(IEnumMediaTypes *iface, REFIID riid, void **ppv)
 919 {
 920     ok(0, "unexpected call\n");
 921     return E_NOTIMPL;
 922 }
 923
 924 static ULONG WINAPI EnumMediaTypes_AddRef(IEnumMediaTypes *iface)
 925 {
 926     return 2;
 927 }
 928
 929 static ULONG WINAPI EnumMediaTypes_Release(IEnumMediaTypes *iface)
 930 {
 931     return 1;
 932 }
 933
 934 static HRESULT WINAPI EnumMediaTypes_Next(IEnumMediaTypes *iface, ULONG cMediaTypes,
 935         AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched)
 936 {
 937     test_filter *This = impl_from_IEnumMediaTypes(iface);
 938     check_calls_list("EnumMediaTypes_Next", ENUMMEDIATYPES_NEXT, This->filter_type);
 939
 940     ok(cMediaTypes == 1, "cMediaTypes = %d\n", cMediaTypes);
 941     ok(ppMediaTypes != NULL, "ppMediaTypes == NULL\n");
 942     ok(pcFetched != NULL, "pcFetched == NULL\n");
 943
 944     if(!This->enum_media_types_pos++) {
 945         ppMediaTypes[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 946         memset(ppMediaTypes[0], 0, sizeof(AM_MEDIA_TYPE));
 947         ppMediaTypes[0]->majortype = MEDIATYPE_Video;
 948         *pcFetched = 1;
 949         return S_OK;
 950     }
 951
 952     *pcFetched = 0;
 953     return S_FALSE;
 954 }
 955
 956 static HRESULT WINAPI EnumMediaTypes_Skip(IEnumMediaTypes *iface, ULONG cMediaTypes)
 957 {
 958     ok(0, "unexpected call\n");
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI EnumMediaTypes_Reset(IEnumMediaTypes *iface)
 963 {
 964     test_filter *This = impl_from_IEnumMediaTypes(iface);
 965     check_calls_list("EnumMediaTypes_Reset", ENUMMEDIATYPES_RESET, This->filter_type);
 966
 967     This->enum_media_types_pos = 0;
 968     return E_FAIL;
 969 }
 970
 971 static HRESULT WINAPI EnumMediaTypes_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **ppEnum)
 972 {
 973     ok(0, "unexpected call\n");
 974     return E_NOTIMPL;
 975 }
 976
 977 static const IEnumMediaTypesVtbl EnumMediaTypesVtbl = {
 978     EnumMediaTypes_QueryInterface,
 979     EnumMediaTypes_AddRef,
 980     EnumMediaTypes_Release,
 981     EnumMediaTypes_Next,
 982     EnumMediaTypes_Skip,
 983     EnumMediaTypes_Reset,
 984     EnumMediaTypes_Clone
 985 };
 986
 987 static void test_CaptureGraphBuilder_RenderStream(void)
 988 {
 989     test_filter source_filter = {{&BaseFilterVtbl}, {&EnumPinsVtbl}, {&PinVtbl},
 990         {&KsPropertySetVtbl}, {&EnumMediaTypesVtbl}, PINDIR_OUTPUT, SOURCE_FILTER};
 991     test_filter sink_filter = {{&BaseFilterVtbl}, {&EnumPinsVtbl}, {&PinVtbl},
 992         {&KsPropertySetVtbl}, {&EnumMediaTypesVtbl}, PINDIR_INPUT, SINK_FILTER};
 993     test_filter intermediate_filter = {{&BaseFilterVtbl}, {&EnumPinsVtbl}, {&PinVtbl},
 994         {&KsPropertySetVtbl}, {&EnumMediaTypesVtbl}, PINDIR_OUTPUT, INTERMEDIATE_FILTER};
 995     ICaptureGraphBuilder2 *cgb;
 996     HRESULT hr;
 997
 998     hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
 999             &IID_ICaptureGraphBuilder2, (void**)&cgb);
1000     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1001             "couldn't create CaptureGraphBuilder, hr = %08x\n", hr);
1002     if(hr != S_OK) {
1003         win_skip("CaptureGraphBuilder is not registered\n");
1004         return;
1005     }
1006
1007     hr = ICaptureGraphBuilder2_SetFiltergraph(cgb, &GraphBuilder);
1008     ok(hr == S_OK, "SetFiltergraph failed: %08x\n", hr);
1009
1010     trace("RenderStream with category and mediatype test\n");
1011     current_calls_list = renderstream_cat_media;
1012     call_no = 0;
1013     hr = ICaptureGraphBuilder2_RenderStream(cgb, &PIN_CATEGORY_EDS,
1014             &MEDIATYPE_Video, (IUnknown*)&source_filter.IBaseFilter_iface,
1015             NULL, &sink_filter.IBaseFilter_iface);
1016     ok(hr == S_OK, "RenderStream failed: %08x\n", hr);
1017     check_calls_list("test_CaptureGraphBuilder_RenderStream", END, NOT_FILTER);
1018
1019     trace("RenderStream with intermediate filter\n");
1020     current_calls_list = renderstream_intermediate;
1021     call_no = 0;
1022     hr = ICaptureGraphBuilder2_RenderStream(cgb, &PIN_CATEGORY_EDS,
1023             &MEDIATYPE_Video, (IUnknown*)&source_filter.IBaseFilter_iface,
1024             &intermediate_filter.IBaseFilter_iface, &sink_filter.IBaseFilter_iface);
1025     ok(hr == S_OK, "RenderStream failed: %08x\n", hr);
1026     check_calls_list("test_CaptureGraphBuilder_RenderStream", END, NOT_FILTER);
1027
1028     ICaptureGraphBuilder2_Release(cgb);
1029 }
1030
1031 static void test_AviMux_QueryInterface(void)
1032 {
1033     IUnknown *avimux, *unk;
1034     HRESULT hr;
1035
1036     hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&avimux);
1037     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1038             "couldn't create AVI Mux filter, hr = %08x\n", hr);
1039     if(hr != S_OK) {
1040         win_skip("AVI Mux filter is not registered\n");
1041         return;
1042     }
1043
1044     hr = IUnknown_QueryInterface(avimux, &IID_IBaseFilter, (void**)&unk);
1045     ok(hr == S_OK, "QueryInterface(IID_IBaseFilter) failed: %x\n", hr);
1046     IUnknown_Release(unk);
1047
1048     hr = IUnknown_QueryInterface(avimux, &IID_IConfigAviMux, (void**)&unk);
1049     ok(hr == S_OK, "QueryInterface(IID_IConfigAviMux) failed: %x\n", hr);
1050     IUnknown_Release(unk);
1051
1052     hr = IUnknown_QueryInterface(avimux, &IID_IConfigInterleaving, (void**)&unk);
1053     ok(hr == S_OK, "QueryInterface(IID_IConfigInterleaving) failed: %x\n", hr);
1054     IUnknown_Release(unk);
1055
1056     hr = IUnknown_QueryInterface(avimux, &IID_IMediaSeeking, (void**)&unk);
1057     ok(hr == S_OK, "QueryInterface(IID_IMediaSeeking) failed: %x\n", hr);
1058     IUnknown_Release(unk);
1059
1060     hr = IUnknown_QueryInterface(avimux, &IID_IPersistMediaPropertyBag, (void**)&unk);
1061     ok(hr == S_OK, "QueryInterface(IID_IPersistMediaPropertyBag) failed: %x\n", hr);
1062     IUnknown_Release(unk);
1063
1064     hr = IUnknown_QueryInterface(avimux, &IID_ISpecifyPropertyPages, (void**)&unk);
1065     ok(hr == S_OK, "QueryInterface(IID_ISpecifyPropertyPages) failed: %x\n", hr);
1066     IUnknown_Release(unk);
1067
1068     IUnknown_Release(avimux);
1069 }
1070
1071 static void test_AviMux(void)
1072 {
1073     test_filter source_filter = {{&BaseFilterVtbl}, {&EnumPinsVtbl}, {&PinVtbl},
1074         {&KsPropertySetVtbl}, {&EnumMediaTypesVtbl}, PINDIR_OUTPUT, SOURCE_FILTER};
1075     VIDEOINFOHEADER videoinfoheader;
1076     IPin *avimux_in, *avimux_out, *pin;
1077     AM_MEDIA_TYPE source_media_type;
1078     AM_MEDIA_TYPE *media_type;
1079     PIN_DIRECTION dir;
1080     IBaseFilter *avimux;
1081     IEnumPins *ep;
1082     IEnumMediaTypes *emt;
1083     HRESULT hr;
1084
1085     hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void**)&avimux);
1086     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1087             "couldn't create AVI Mux filter, hr = %08x\n", hr);
1088     if(hr != S_OK) {
1089         win_skip("AVI Mux filter is not registered\n");
1090         return;
1091     }
1092
1093     hr = IBaseFilter_EnumPins(avimux, &ep);
1094     ok(hr == S_OK, "EnumPins returned %x\n", hr);
1095
1096     hr = IEnumPins_Next(ep, 1, &avimux_out, NULL);
1097     ok(hr == S_OK, "Next returned %x\n", hr);
1098     hr = IPin_QueryDirection(avimux_out, &dir);
1099     ok(hr == S_OK, "QueryDirection returned %x\n", hr);
1100     ok(dir == PINDIR_OUTPUT, "dir = %d\n", dir);
1101
1102     hr = IEnumPins_Next(ep, 1, &avimux_in, NULL);
1103     ok(hr == S_OK, "Next returned %x\n", hr);
1104     hr = IPin_QueryDirection(avimux_in, &dir);
1105     ok(hr == S_OK, "QueryDirection returned %x\n", hr);
1106     ok(dir == PINDIR_INPUT, "dir = %d\n", dir);
1107     IEnumPins_Release(ep);
1108
1109     hr = IPin_EnumMediaTypes(avimux_out, &emt);
1110     ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr);
1111     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1112     ok(hr == S_OK, "Next returned %x\n", hr);
1113     ok(IsEqualIID(&media_type->majortype, &MEDIATYPE_Stream), "majortype = %s\n",
1114             debugstr_guid(&media_type->majortype));
1115     ok(IsEqualIID(&media_type->subtype, &MEDIASUBTYPE_Avi), "subtype = %s\n",
1116             debugstr_guid(&media_type->subtype));
1117     ok(media_type->bFixedSizeSamples, "bFixedSizeSamples = %x\n", media_type->bFixedSizeSamples);
1118     ok(!media_type->bTemporalCompression, "bTemporalCompression = %x\n", media_type->bTemporalCompression);
1119     ok(media_type->lSampleSize == 1, "lSampleSize = %d\n", media_type->lSampleSize);
1120     ok(IsEqualIID(&media_type->formattype, &GUID_NULL), "formattype = %s\n",
1121             debugstr_guid(&media_type->formattype));
1122     ok(!media_type->pUnk, "pUnk = %p\n", media_type->pUnk);
1123     ok(!media_type->cbFormat, "cbFormat = %d\n", media_type->cbFormat);
1124     ok(!media_type->pbFormat, "pbFormat = %p\n", media_type->pbFormat);
1125     CoTaskMemFree(media_type);
1126     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1127     ok(hr == S_FALSE, "Next returned %x\n", hr);
1128     IEnumMediaTypes_Release(emt);
1129
1130     hr = IPin_EnumMediaTypes(avimux_in, &emt);
1131     ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr);
1132     hr = IEnumMediaTypes_Reset(emt);
1133     ok(hr == S_OK, "Reset returned %x\n", hr);
1134     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1135     ok(hr == S_FALSE, "Next returned %x\n", hr);
1136     IEnumMediaTypes_Release(emt);
1137
1138     hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, NULL);
1139     ok(hr == E_POINTER, "ReceiveConnection returned %x\n", hr);
1140
1141     current_calls_list = NULL;
1142     memset(&source_media_type, 0, sizeof(AM_MEDIA_TYPE));
1143     memset(&videoinfoheader, 0, sizeof(VIDEOINFOHEADER));
1144     source_media_type.majortype = MEDIATYPE_Video;
1145     source_media_type.subtype = MEDIASUBTYPE_RGB32;
1146     source_media_type.formattype = FORMAT_VideoInfo;
1147     source_media_type.bFixedSizeSamples = TRUE;
1148     source_media_type.lSampleSize = 40000;
1149     source_media_type.cbFormat = sizeof(VIDEOINFOHEADER);
1150     source_media_type.pbFormat = (BYTE*)&videoinfoheader;
1151     videoinfoheader.AvgTimePerFrame = 333333;
1152     videoinfoheader.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1153     videoinfoheader.bmiHeader.biWidth = 100;
1154     videoinfoheader.bmiHeader.biHeight = 100;
1155     videoinfoheader.bmiHeader.biPlanes = 1;
1156     videoinfoheader.bmiHeader.biBitCount = 32;
1157     videoinfoheader.bmiHeader.biSizeImage = 40000;
1158     videoinfoheader.bmiHeader.biClrImportant = 256;
1159     hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, &source_media_type);
1160     ok(hr == S_OK, "ReceiveConnection returned %x\n", hr);
1161
1162     hr = IPin_ConnectedTo(avimux_in, &pin);
1163     ok(hr == S_OK, "ConnectedTo returned %x\n", hr);
1164     ok(pin == &source_filter.IPin_iface, "incorrect pin: %p, expected %p\n",
1165             pin, &source_filter.IPin_iface);
1166
1167     IPin_Release(avimux_in);
1168     IPin_Release(avimux_out);
1169     IBaseFilter_Release(avimux);
1170 }
1171
1172 START_TEST(qcap)
1173 {
1174     if (SUCCEEDED(CoInitialize(NULL)))
1175     {
1176         test_smart_tee_filter();
1177         test_CaptureGraphBuilder_RenderStream();
1178         test_AviMux_QueryInterface();
1179         test_AviMux();
1180         CoUninitialize();
1181     }
1182     else
1183         skip("CoInitialize failed\n");
1184 }