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 #define DEFINE_EXPECT(func) \
  35     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  36
  37 #define SET_EXPECT(func) \
  38     expect_ ## func = TRUE
  39
  40 #define CHECK_EXPECT2(func) \
  41     do { \
  42         ok(expect_ ##func, "unexpected call " #func "\n"); \
  43         called_ ## func = TRUE; \
  44     }while(0)
  45
  46 #define CHECK_EXPECT(func) \
  47     do { \
  48         CHECK_EXPECT2(func); \
  49         expect_ ## func = FALSE; \
  50     }while(0)
  51
  52 #define CHECK_CALLED(func) \
  53     do { \
  54         ok(called_ ## func, "expected " #func "\n"); \
  55         expect_ ## func = called_ ## func = FALSE; \
  56     }while(0)
  57
  58 DEFINE_EXPECT(ReceiveConnection);
  59 DEFINE_EXPECT(GetAllocatorRequirements);
  60 DEFINE_EXPECT(NotifyAllocator);
  61 DEFINE_EXPECT(Reconnect);
  62 DEFINE_EXPECT(Read_FccHandler);
  63 DEFINE_EXPECT(MediaSeeking_GetPositions);
  64 DEFINE_EXPECT(MemAllocator_GetProperties);
  65 DEFINE_EXPECT(MemInputPin_QueryInterface_IStream);
  66 DEFINE_EXPECT(MediaSample_QueryInterface_MediaSample2);
  67 DEFINE_EXPECT(MediaSample_IsDiscontinuity);
  68 DEFINE_EXPECT(MediaSample_IsPreroll);
  69 DEFINE_EXPECT(MediaSample_IsSyncPoint);
  70 DEFINE_EXPECT(MediaSample_GetTime);
  71 DEFINE_EXPECT(MediaSample_GetMediaType);
  72 DEFINE_EXPECT(MediaSample_GetPointer);
  73 DEFINE_EXPECT(MediaSample_GetActualDataLength);
  74 DEFINE_EXPECT(MediaSample_GetSize);
  75 DEFINE_EXPECT(MediaSample_GetMediaTime);
  76
  77 static int strcmp_wa(LPCWSTR strw, const char *stra)
  78 {
  79     CHAR buf[512];
  80     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
  81     return lstrcmpA(stra, buf);
  82 }
  83
  84 static BSTR a2bstr(const char *str)
  85 {
  86     BSTR ret;
  87     int len;
  88
  89     if(!str)
  90         return NULL;
  91
  92     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  93     ret = SysAllocStringLen(NULL, len-1);
  94     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  95
  96     return ret;
  97 }
  98
  99 static void test_smart_tee_filter(void)
 100 {
 101     HRESULT hr;
 102     IBaseFilter *smartTeeFilter = NULL;
 103     IEnumPins *enumPins = NULL;
 104     IPin *pin;
 105     FILTER_INFO filterInfo;
 106     int pinNumber = 0;
 107
 108     hr = CoCreateInstance(&CLSID_SmartTee, NULL, CLSCTX_INPROC_SERVER,
 109             &IID_IBaseFilter, (void**)&smartTeeFilter);
 110     todo_wine ok(SUCCEEDED(hr), "couldn't create smart tee filter, hr=%08x\n", hr);
 111     if (FAILED(hr))
 112         goto end;
 113
 114     hr = IBaseFilter_QueryFilterInfo(smartTeeFilter, &filterInfo);
 115     ok(SUCCEEDED(hr), "QueryFilterInfo failed, hr=%08x\n", hr);
 116     if (FAILED(hr))
 117         goto end;
 118
 119     ok(lstrlenW(filterInfo.achName) == 0,
 120             "filter's name is meant to be empty but it's %s\n", wine_dbgstr_w(filterInfo.achName));
 121
 122     hr = IBaseFilter_EnumPins(smartTeeFilter, &enumPins);
 123     ok(SUCCEEDED(hr), "cannot enum filter pins, hr=%08x\n", hr);
 124     if (FAILED(hr))
 125         goto end;
 126
 127     while (IEnumPins_Next(enumPins, 1, &pin, NULL) == S_OK)
 128     {
 129         PIN_INFO pinInfo;
 130         hr = IPin_QueryPinInfo(pin, &pinInfo);
 131         ok(SUCCEEDED(hr), "QueryPinInfo failed, hr=%08x\n", hr);
 132         if (FAILED(hr))
 133             goto endwhile;
 134
 135         if (pinNumber == 0)
 136         {
 137             static const WCHAR wszInput[] = {'I','n','p','u','t',0};
 138             ok(pinInfo.dir == PINDIR_INPUT, "pin 0 isn't an input pin\n");
 139             ok(!lstrcmpW(pinInfo.achName, wszInput), "pin 0 is called %s, not 'Input'\n", wine_dbgstr_w(pinInfo.achName));
 140         }
 141         else if (pinNumber == 1)
 142         {
 143             static const WCHAR wszCapture[] = {'C','a','p','t','u','r','e',0};
 144             ok(pinInfo.dir == PINDIR_OUTPUT, "pin 1 isn't an output pin\n");
 145             ok(!lstrcmpW(pinInfo.achName, wszCapture), "pin 1 is called %s, not 'Capture'\n", wine_dbgstr_w(pinInfo.achName));
 146         }
 147         else if (pinNumber == 2)
 148         {
 149             static const WCHAR wszPreview[] = {'P','r','e','v','i','e','w',0};
 150             ok(pinInfo.dir == PINDIR_OUTPUT, "pin 2 isn't an output pin\n");
 151             ok(!lstrcmpW(pinInfo.achName, wszPreview), "pin 2 is called %s, not 'Preview'\n", wine_dbgstr_w(pinInfo.achName));
 152         }
 153         else
 154             ok(0, "pin %d isn't supposed to exist\n", pinNumber);
 155
 156     endwhile:
 157         IPin_Release(pin);
 158         pinNumber++;
 159     }
 160
 161 end:
 162     if (smartTeeFilter)
 163         IBaseFilter_Release(smartTeeFilter);
 164     if (enumPins)
 165         IEnumPins_Release(enumPins);
 166 }
 167
 168 typedef enum {
 169     SOURCE_FILTER,
 170     SINK_FILTER,
 171     INTERMEDIATE_FILTER,
 172     NOT_FILTER
 173 } filter_type;
 174
 175 static const char* debugstr_filter_type(filter_type type)
 176 {
 177     switch(type) {
 178     case SOURCE_FILTER:
 179         return "SOURCE_FILTER";
 180     case SINK_FILTER:
 181         return "SINK_FILTER";
 182     case INTERMEDIATE_FILTER:
 183         return "INTERMEDIATE_FILTER";
 184     default:
 185         return "NOT_FILTER";
 186     }
 187 }
 188
 189 typedef enum {
 190     BASEFILTER_ENUMPINS,
 191     ENUMPINS_NEXT,
 192     PIN_QUERYDIRECTION,
 193     PIN_CONNECTEDTO,
 194     PIN_QUERYPININFO,
 195     KSPROPERTYSET_GET,
 196     PIN_ENUMMEDIATYPES,
 197     ENUMMEDIATYPES_RESET,
 198     ENUMMEDIATYPES_NEXT,
 199     GRAPHBUILDER_CONNECT,
 200     BASEFILTER_GETSTATE,
 201     BASEFILTER_QUERYINTERFACE,
 202     END
 203 } call_id;
 204
 205 static const struct {
 206     call_id call_id;
 207     filter_type filter_type;
 208     BOOL wine_missing;
 209     BOOL wine_extra;
 210     BOOL optional; /* fails on wine if missing */
 211     BOOL broken;
 212 } renderstream_cat_media[] = {
 213     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 214     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 215     {ENUMPINS_NEXT, SOURCE_FILTER},
 216     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 217     {PIN_CONNECTEDTO, SOURCE_FILTER},
 218     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 219     {KSPROPERTYSET_GET, SOURCE_FILTER},
 220     {PIN_ENUMMEDIATYPES, SOURCE_FILTER},
 221     {ENUMMEDIATYPES_RESET, SOURCE_FILTER},
 222     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER},
 223     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 224     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 225     {ENUMPINS_NEXT, SOURCE_FILTER},
 226     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 227     {PIN_CONNECTEDTO, SOURCE_FILTER},
 228     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 229     {KSPROPERTYSET_GET, SOURCE_FILTER},
 230     {ENUMPINS_NEXT, SOURCE_FILTER},
 231     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 232     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 233     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 234     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 235     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 236     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 237     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 238     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 239     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 240     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 241     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 242     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 243     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 244     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 245     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 246     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 247     {PIN_ENUMMEDIATYPES, SOURCE_FILTER, TRUE, FALSE, TRUE},
 248     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER, TRUE, FALSE, TRUE},
 249     {BASEFILTER_QUERYINTERFACE, SINK_FILTER, FALSE, TRUE},
 250     {BASEFILTER_ENUMPINS, SINK_FILTER},
 251     {ENUMPINS_NEXT, SINK_FILTER},
 252     {PIN_QUERYDIRECTION, SINK_FILTER},
 253     {PIN_CONNECTEDTO, SINK_FILTER},
 254     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 255     {BASEFILTER_GETSTATE, SOURCE_FILTER, TRUE, FALSE, TRUE},
 256     {BASEFILTER_ENUMPINS, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 257     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 258     {PIN_QUERYDIRECTION, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 259     {PIN_CONNECTEDTO, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 260     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 261     {END, NOT_FILTER}
 262 }, renderstream_intermediate[] = {
 263     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 264     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 265     {ENUMPINS_NEXT, SOURCE_FILTER},
 266     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 267     {PIN_CONNECTEDTO, SOURCE_FILTER},
 268     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 269     {KSPROPERTYSET_GET, SOURCE_FILTER},
 270     {PIN_ENUMMEDIATYPES, SOURCE_FILTER},
 271     {ENUMMEDIATYPES_RESET, SOURCE_FILTER},
 272     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER},
 273     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER},
 274     {BASEFILTER_ENUMPINS, SOURCE_FILTER},
 275     {ENUMPINS_NEXT, SOURCE_FILTER},
 276     {PIN_QUERYDIRECTION, SOURCE_FILTER},
 277     {PIN_CONNECTEDTO, SOURCE_FILTER},
 278     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 279     {KSPROPERTYSET_GET, SOURCE_FILTER},
 280     {ENUMPINS_NEXT, SOURCE_FILTER},
 281     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 282     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 283     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 284     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 285     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 286     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 287     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 288     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 289     {BASEFILTER_QUERYINTERFACE, SOURCE_FILTER, TRUE},
 290     {BASEFILTER_ENUMPINS, SOURCE_FILTER, TRUE},
 291     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 292     {PIN_QUERYDIRECTION, SOURCE_FILTER, TRUE},
 293     {PIN_CONNECTEDTO, SOURCE_FILTER, TRUE},
 294     {PIN_QUERYPININFO, SOURCE_FILTER, TRUE},
 295     {KSPROPERTYSET_GET, SOURCE_FILTER, TRUE},
 296     {ENUMPINS_NEXT, SOURCE_FILTER, TRUE},
 297     {PIN_ENUMMEDIATYPES, SOURCE_FILTER, TRUE, FALSE, TRUE},
 298     {ENUMMEDIATYPES_NEXT, SOURCE_FILTER, TRUE, FALSE, TRUE},
 299     {BASEFILTER_QUERYINTERFACE, SINK_FILTER, FALSE, TRUE},
 300     {BASEFILTER_ENUMPINS, SINK_FILTER},
 301     {ENUMPINS_NEXT, SINK_FILTER},
 302     {PIN_QUERYDIRECTION, SINK_FILTER},
 303     {PIN_CONNECTEDTO, SINK_FILTER},
 304     {BASEFILTER_QUERYINTERFACE, INTERMEDIATE_FILTER, FALSE, TRUE},
 305     {BASEFILTER_ENUMPINS, INTERMEDIATE_FILTER},
 306     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 307     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 308     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 309     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 310     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 311     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 312     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 313     {BASEFILTER_QUERYINTERFACE, INTERMEDIATE_FILTER, FALSE, TRUE},
 314     {BASEFILTER_ENUMPINS, INTERMEDIATE_FILTER},
 315     {ENUMPINS_NEXT, INTERMEDIATE_FILTER},
 316     {PIN_QUERYDIRECTION, INTERMEDIATE_FILTER},
 317     {PIN_CONNECTEDTO, INTERMEDIATE_FILTER},
 318     {GRAPHBUILDER_CONNECT, NOT_FILTER},
 319     {BASEFILTER_GETSTATE, SOURCE_FILTER, TRUE, FALSE, TRUE},
 320     {BASEFILTER_ENUMPINS, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 321     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 322     {PIN_QUERYDIRECTION, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 323     {PIN_CONNECTEDTO, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 324     {ENUMPINS_NEXT, SOURCE_FILTER, FALSE, FALSE, FALSE, TRUE},
 325     {END, NOT_FILTER}
 326 }, *current_calls_list;
 327 int call_no;
 328
 329 static void check_calls_list(const char *func, call_id id, filter_type type)
 330 {
 331     if(!current_calls_list)
 332         return;
 333
 334     while(current_calls_list[call_no].wine_missing || current_calls_list[call_no].wine_extra ||
 335          current_calls_list[call_no].optional || current_calls_list[call_no].broken) {
 336         if(current_calls_list[call_no].wine_missing) {
 337             todo_wine ok((current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 338                     broken(current_calls_list[call_no].optional && (current_calls_list[call_no].call_id != id ||
 339                             current_calls_list[call_no].filter_type != type)),
 340                     "missing call, got %s(%d), expected %d (%d)\n", func, id, current_calls_list[call_no].call_id, call_no);
 341
 342             if(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type)
 343                 call_no++;
 344             else
 345                 break;
 346         }else if(current_calls_list[call_no].wine_extra) {
 347             todo_wine ok(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type,
 348                     "extra call, got %s(%d) (%d)\n", func, id, call_no);
 349
 350             if(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) {
 351                 call_no++;
 352                 return;
 353             }
 354             call_no++;
 355         }else if(current_calls_list[call_no].optional) {
 356             ok((current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 357                     broken(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type),
 358                     "unexpected call: %s on %s (%d)\n", func, debugstr_filter_type(type), call_no);
 359
 360             if(current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type)
 361                 call_no++;
 362             else
 363                 break;
 364         }else if(current_calls_list[call_no].broken) {
 365             ok(broken(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type) ||
 366                     (current_calls_list[call_no].call_id != id || current_calls_list[call_no].filter_type != type),
 367                     "unexpected call: %s on %s (%d)\n", func, debugstr_filter_type(type), call_no);
 368
 369             if(current_calls_list[call_no].call_id == id && current_calls_list[call_no].filter_type == type)
 370                 break;
 371             call_no++;
 372         }
 373     }
 374
 375     ok(current_calls_list[call_no].call_id == id, "unexpected call: %s on %s (%d)\n",
 376             func, debugstr_filter_type(type), call_no);
 377     if(current_calls_list[call_no].call_id != id)
 378         return;
 379
 380     ok(current_calls_list[call_no].filter_type == type, "unexpected call: %s on %s (%d)\n",
 381             func, debugstr_filter_type(type), call_no);
 382     if(current_calls_list[call_no].filter_type != type)
 383         return;
 384
 385     call_no++;
 386 }
 387
 388 static HRESULT WINAPI GraphBuilder_QueryInterface(
 389         IGraphBuilder *iface, REFIID riid, void **ppv)
 390 {
 391     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IFilterGraph)
 392             || IsEqualIID(riid, &IID_IGraphBuilder))
 393     {
 394         *ppv = iface;
 395         return S_OK;
 396     }
 397
 398     ok(IsEqualIID(riid, &IID_IMediaEvent) || IsEqualIID(riid, &IID_IMediaEventSink),
 399             "QueryInterface(%s)\n", wine_dbgstr_guid(riid));
 400     *ppv = NULL;
 401     return E_NOINTERFACE;
 402 }
 403
 404 static ULONG WINAPI GraphBuilder_AddRef(IGraphBuilder *iface)
 405 {
 406     return 2;
 407 }
 408
 409 static ULONG WINAPI GraphBuilder_Release(IGraphBuilder *iface)
 410 {
 411     return 1;
 412 }
 413
 414 static HRESULT WINAPI GraphBuilder_AddFilter(IGraphBuilder *iface,
 415         IBaseFilter *pFilter, LPCWSTR pName)
 416 {
 417     ok(0, "unexpected call\n");
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI GraphBuilder_RemoveFilter(
 422         IGraphBuilder *iface, IBaseFilter *pFilter)
 423 {
 424     ok(0, "unexpected call\n");
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI GraphBuilder_EnumFilters(
 429         IGraphBuilder *iface, IEnumFilters **ppEnum)
 430 {
 431     ok(0, "unexpected call\n");
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI GraphBuilder_FindFilterByName(IGraphBuilder *iface,
 436         LPCWSTR pName, IBaseFilter **ppFilter)
 437 {
 438     ok(0, "unexpected call\n");
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI GraphBuilder_ConnectDirect(IGraphBuilder *iface,
 443         IPin *ppinOut, IPin *ppinIn, const AM_MEDIA_TYPE *pmt)
 444 {
 445     ok(0, "unexpected call\n");
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI GraphBuilder_Reconnect(IGraphBuilder *iface, IPin *ppin)
 450 {
 451     CHECK_EXPECT(Reconnect);
 452     return S_OK;
 453 }
 454
 455 static HRESULT WINAPI GraphBuilder_Disconnect(IGraphBuilder *iface, IPin *ppin)
 456 {
 457     ok(0, "unexpected call\n");
 458     return E_NOTIMPL;
 459 }
 460
 461 static HRESULT WINAPI GraphBuilder_SetDefaultSyncSource(IGraphBuilder *iface)
 462 {
 463     ok(0, "unexpected call\n");
 464     return E_NOTIMPL;
 465 }
 466
 467 static HRESULT WINAPI GraphBuilder_Connect(IGraphBuilder *iface, IPin *ppinOut, IPin *ppinIn)
 468 {
 469     check_calls_list("GraphBuilder_Connect", GRAPHBUILDER_CONNECT, NOT_FILTER);
 470     return S_OK;
 471 }
 472
 473 static HRESULT WINAPI GraphBuilder_Render(IGraphBuilder *iface, IPin *ppinOut)
 474 {
 475     ok(0, "unexpected call\n");
 476     return E_NOTIMPL;
 477 }
 478
 479 static HRESULT WINAPI GraphBuilder_RenderFile(IGraphBuilder *iface,
 480         LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
 481 {
 482     ok(0, "unexpected call\n");
 483     return E_NOTIMPL;
 484 }
 485
 486 static HRESULT WINAPI GraphBuilder_AddSourceFilter(IGraphBuilder *iface, LPCWSTR lpcwstrFileName,
 487         LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
 488 {
 489     ok(0, "unexpected call\n");
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI GraphBuilder_SetLogFile(IGraphBuilder *iface, DWORD_PTR hFile)
 494 {
 495     ok(0, "unexpected call\n");
 496     return E_NOTIMPL;
 497 }
 498
 499 static HRESULT WINAPI GraphBuilder_Abort(IGraphBuilder *iface)
 500 {
 501     ok(0, "unexpected call\n");
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI GraphBuilder_ShouldOperationContinue(IGraphBuilder *iface)
 506 {
 507     ok(0, "unexpected call\n");
 508     return E_NOTIMPL;
 509 }
 510
 511 static const IGraphBuilderVtbl GraphBuilder_vtbl = {
 512     GraphBuilder_QueryInterface,
 513     GraphBuilder_AddRef,
 514     GraphBuilder_Release,
 515     GraphBuilder_AddFilter,
 516     GraphBuilder_RemoveFilter,
 517     GraphBuilder_EnumFilters,
 518     GraphBuilder_FindFilterByName,
 519     GraphBuilder_ConnectDirect,
 520     GraphBuilder_Reconnect,
 521     GraphBuilder_Disconnect,
 522     GraphBuilder_SetDefaultSyncSource,
 523     GraphBuilder_Connect,
 524     GraphBuilder_Render,
 525     GraphBuilder_RenderFile,
 526     GraphBuilder_AddSourceFilter,
 527     GraphBuilder_SetLogFile,
 528     GraphBuilder_Abort,
 529     GraphBuilder_ShouldOperationContinue
 530 };
 531
 532 static IGraphBuilder GraphBuilder = {&GraphBuilder_vtbl};
 533
 534 typedef struct {
 535     IBaseFilter IBaseFilter_iface;
 536     IEnumPins IEnumPins_iface;
 537     IPin IPin_iface;
 538     IKsPropertySet IKsPropertySet_iface;
 539     IMemInputPin IMemInputPin_iface;
 540     IMediaSeeking IMediaSeeking_iface;
 541     IEnumMediaTypes IEnumMediaTypes_iface;
 542
 543     PIN_DIRECTION dir;
 544     filter_type filter_type;
 545
 546     int enum_pins_pos;
 547     int enum_media_types_pos;
 548 } test_filter;
 549
 550 static test_filter* impl_from_IBaseFilter(IBaseFilter *iface)
 551 {
 552     return CONTAINING_RECORD(iface, test_filter, IBaseFilter_iface);
 553 }
 554
 555 static HRESULT WINAPI BaseFilter_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv)
 556 {
 557     test_filter *This = impl_from_IBaseFilter(iface);
 558
 559     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPersist)
 560             || IsEqualIID(riid, &IID_IMediaFilter) || IsEqualIID(riid, &IID_IBaseFilter)) {
 561         *ppv = iface;
 562         return S_OK;
 563     }
 564
 565     check_calls_list("BaseFilter_QueryInterface", BASEFILTER_QUERYINTERFACE, This->filter_type);
 566     ok(IsEqualIID(riid, &IID_IPin), "riid = %s\n", wine_dbgstr_guid(riid));
 567     return E_NOINTERFACE;
 568 }
 569
 570 static ULONG WINAPI BaseFilter_AddRef(IBaseFilter *iface)
 571 {
 572     return 2;
 573 }
 574
 575 static ULONG WINAPI BaseFilter_Release(IBaseFilter *iface)
 576 {
 577     return 1;
 578 }
 579
 580 static HRESULT WINAPI BaseFilter_GetClassID(IBaseFilter *iface, CLSID *pClassID)
 581 {
 582     ok(0, "unexpected call\n");
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI BaseFilter_Stop(IBaseFilter *iface)
 587 {
 588     ok(0, "unexpected call\n");
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI BaseFilter_Pause(IBaseFilter *iface)
 593 {
 594     ok(0, "unexpected call\n");
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI BaseFilter_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
 599 {
 600     ok(0, "unexpected call\n");
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI BaseFilter_GetState(IBaseFilter *iface,
 605         DWORD dwMilliSecsTimeout, FILTER_STATE *State)
 606 {
 607     test_filter *This = impl_from_IBaseFilter(iface);
 608     check_calls_list("BaseFilter_GetState", BASEFILTER_GETSTATE, This->filter_type);
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT WINAPI BaseFilter_SetSyncSource(
 613         IBaseFilter *iface, IReferenceClock *pClock)
 614 {
 615     ok(0, "unexpected call\n");
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT WINAPI BaseFilter_GetSyncSource(
 620         IBaseFilter *iface, IReferenceClock **pClock)
 621 {
 622     ok(0, "unexpected call\n");
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI BaseFilter_EnumPins(
 627         IBaseFilter *iface, IEnumPins **ppEnum)
 628 {
 629     test_filter *This = impl_from_IBaseFilter(iface);
 630     check_calls_list("BaseFilter_EnumPins", BASEFILTER_ENUMPINS, This->filter_type);
 631
 632     *ppEnum = &This->IEnumPins_iface;
 633     This->enum_pins_pos = 0;
 634     return S_OK;
 635 }
 636
 637 static HRESULT WINAPI BaseFilter_FindPin(IBaseFilter *iface,
 638         LPCWSTR Id, IPin **ppPin)
 639 {
 640     ok(0, "unexpected call\n");
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI BaseFilter_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo)
 645 {
 646     ok(0, "unexpected call\n");
 647     return E_NOTIMPL;
 648 }
 649
 650 static HRESULT WINAPI BaseFilter_JoinFilterGraph(IBaseFilter *iface,
 651         IFilterGraph *pGraph, LPCWSTR pName)
 652 {
 653     ok(0, "unexpected call\n");
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI BaseFilter_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo)
 658 {
 659     ok(0, "unexpected call\n");
 660     return E_NOTIMPL;
 661 }
 662
 663 static const IBaseFilterVtbl BaseFilterVtbl = {
 664     BaseFilter_QueryInterface,
 665     BaseFilter_AddRef,
 666     BaseFilter_Release,
 667     BaseFilter_GetClassID,
 668     BaseFilter_Stop,
 669     BaseFilter_Pause,
 670     BaseFilter_Run,
 671     BaseFilter_GetState,
 672     BaseFilter_SetSyncSource,
 673     BaseFilter_GetSyncSource,
 674     BaseFilter_EnumPins,
 675     BaseFilter_FindPin,
 676     BaseFilter_QueryFilterInfo,
 677     BaseFilter_JoinFilterGraph,
 678     BaseFilter_QueryVendorInfo
 679 };
 680
 681 static test_filter* impl_from_IEnumPins(IEnumPins *iface)
 682 {
 683     return CONTAINING_RECORD(iface, test_filter, IEnumPins_iface);
 684 }
 685
 686 static HRESULT WINAPI EnumPins_QueryInterface(IEnumPins *iface, REFIID riid, void **ppv)
 687 {
 688     ok(0, "unexpected call\n");
 689     return E_NOTIMPL;
 690 }
 691
 692 static ULONG WINAPI EnumPins_AddRef(IEnumPins *iface)
 693 {
 694     return 2;
 695 }
 696
 697 static ULONG WINAPI EnumPins_Release(IEnumPins *iface)
 698 {
 699     return 1;
 700 }
 701
 702 static HRESULT WINAPI EnumPins_Next(IEnumPins *iface,
 703         ULONG cPins, IPin **ppPins, ULONG *pcFetched)
 704 {
 705     test_filter *This = impl_from_IEnumPins(iface);
 706     check_calls_list("EnumPins_Next", ENUMPINS_NEXT, This->filter_type);
 707
 708     ok(cPins == 1, "cPins = %d\n", cPins);
 709     ok(ppPins != NULL, "ppPins == NULL\n");
 710     ok(pcFetched != NULL, "pcFetched == NULL\n");
 711
 712     if(This->enum_pins_pos++ < (This->filter_type == INTERMEDIATE_FILTER ? 2 : 1)) {
 713         *ppPins = &This->IPin_iface;
 714         *pcFetched = 1;
 715         return S_OK;
 716     }
 717     *pcFetched = 0;
 718     return S_FALSE;
 719 }
 720
 721 static HRESULT WINAPI EnumPins_Skip(IEnumPins *iface, ULONG cPins)
 722 {
 723     ok(0, "unexpected call\n");
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI EnumPins_Reset(IEnumPins *iface)
 728 {
 729     ok(0, "unexpected call\n");
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI EnumPins_Clone(IEnumPins *iface, IEnumPins **ppEnum)
 734 {
 735     ok(0, "unexpected call\n");
 736     return E_NOTIMPL;
 737 }
 738
 739 static const IEnumPinsVtbl EnumPinsVtbl = {
 740     EnumPins_QueryInterface,
 741     EnumPins_AddRef,
 742     EnumPins_Release,
 743     EnumPins_Next,
 744     EnumPins_Skip,
 745     EnumPins_Reset,
 746     EnumPins_Clone
 747 };
 748
 749 static test_filter* impl_from_IPin(IPin *iface)
 750 {
 751     return CONTAINING_RECORD(iface, test_filter, IPin_iface);
 752 }
 753
 754 static HRESULT WINAPI Pin_QueryInterface(IPin *iface, REFIID riid, void **ppv)
 755 {
 756     test_filter *This = impl_from_IPin(iface);
 757
 758     if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPin)) {
 759         *ppv = iface;
 760         return S_OK;
 761     }
 762
 763     if(IsEqualIID(riid, &IID_IKsPropertySet)) {
 764         *ppv = &This->IKsPropertySet_iface;
 765         return S_OK;
 766     }
 767
 768     if(IsEqualIID(riid, &IID_IMemInputPin)) {
 769         *ppv = &This->IMemInputPin_iface;
 770         return S_OK;
 771     }
 772
 773     if(IsEqualIID(riid, &IID_IMediaSeeking)) {
 774         *ppv = &This->IMediaSeeking_iface;
 775         return S_OK;
 776     }
 777
 778     ok(0, "unexpected call: %s\n", wine_dbgstr_guid(riid));
 779     *ppv = NULL;
 780     return E_NOINTERFACE;
 781 }
 782
 783 static ULONG WINAPI Pin_AddRef(IPin *iface)
 784 {
 785     return 2;
 786 }
 787
 788 static ULONG WINAPI Pin_Release(IPin *iface)
 789 {
 790     return 1;
 791 }
 792
 793 static HRESULT WINAPI Pin_Connect(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 794 {
 795     ok(0, "unexpected call\n");
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT WINAPI Pin_ReceiveConnection(IPin *iface,
 800         IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 801 {
 802     CHECK_EXPECT(ReceiveConnection);
 803
 804     ok(IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream), "majortype = %s\n",
 805             wine_dbgstr_guid(&pmt->majortype));
 806     ok(IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_Avi), "subtype = %s\n",
 807             wine_dbgstr_guid(&pmt->subtype));
 808     ok(pmt->bFixedSizeSamples, "bFixedSizeSamples = %x\n", pmt->bFixedSizeSamples);
 809     ok(!pmt->bTemporalCompression, "bTemporalCompression = %x\n", pmt->bTemporalCompression);
 810     ok(pmt->lSampleSize == 1, "lSampleSize = %d\n", pmt->lSampleSize);
 811     ok(IsEqualIID(&pmt->formattype, &GUID_NULL), "formattype = %s\n",
 812             wine_dbgstr_guid(&pmt->formattype));
 813     ok(!pmt->pUnk, "pUnk = %p\n", pmt->pUnk);
 814     ok(!pmt->cbFormat, "cbFormat = %d\n", pmt->cbFormat);
 815     ok(!pmt->pbFormat, "pbFormat = %p\n", pmt->pbFormat);
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI Pin_Disconnect(IPin *iface)
 820 {
 821     ok(0, "unexpected call\n");
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI Pin_ConnectedTo(IPin *iface, IPin **pPin)
 826 {
 827     test_filter *This = impl_from_IPin(iface);
 828     check_calls_list("Pin_ConnectedTo", PIN_CONNECTEDTO, This->filter_type);
 829
 830     *pPin = NULL;
 831     return S_OK;
 832 }
 833
 834 static HRESULT WINAPI Pin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *pmt)
 835 {
 836     ok(0, "unexpected call\n");
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI Pin_QueryPinInfo(IPin *iface, PIN_INFO *pInfo)
 841 {
 842     test_filter *This = impl_from_IPin(iface);
 843     check_calls_list("Pin_QueryPinInfo", PIN_QUERYPININFO, This->filter_type);
 844     return E_NOTIMPL;
 845 }
 846
 847 static HRESULT WINAPI Pin_QueryDirection(IPin *iface, PIN_DIRECTION *pPinDir)
 848 {
 849     test_filter *This = impl_from_IPin(iface);
 850     check_calls_list("Pin_QueryDirection", PIN_QUERYDIRECTION, This->filter_type);
 851
 852     *pPinDir = This->dir;
 853     if(This->filter_type==INTERMEDIATE_FILTER && This->enum_pins_pos==2)
 854         *pPinDir = PINDIR_INPUT;
 855     return S_OK;
 856 }
 857
 858 static HRESULT WINAPI Pin_QueryId(IPin *iface, LPWSTR *Id)
 859 {
 860     ok(0, "unexpected call\n");
 861     return E_NOTIMPL;
 862 }
 863
 864 static HRESULT WINAPI Pin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt)
 865 {
 866     ok(0, "unexpected call\n");
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI Pin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum)
 871 {
 872     test_filter *This = impl_from_IPin(iface);
 873     check_calls_list("Pin_EnumMediaTypes", PIN_ENUMMEDIATYPES, This->filter_type);
 874
 875     ok(ppEnum != NULL, "ppEnum == NULL\n");
 876     *ppEnum = &This->IEnumMediaTypes_iface;
 877     return S_OK;
 878 }
 879
 880 static HRESULT WINAPI Pin_QueryInternalConnections(IPin *iface, IPin **apPin, ULONG *nPin)
 881 {
 882     ok(0, "unexpected call\n");
 883     return E_NOTIMPL;
 884 }
 885
 886 static HRESULT WINAPI Pin_EndOfStream(IPin *iface)
 887 {
 888     ok(0, "unexpected call\n");
 889     return E_NOTIMPL;
 890 }
 891
 892 static HRESULT WINAPI Pin_BeginFlush(IPin *iface)
 893 {
 894     ok(0, "unexpected call\n");
 895     return E_NOTIMPL;
 896 }
 897
 898 static HRESULT WINAPI Pin_EndFlush(IPin *iface)
 899 {
 900     ok(0, "unexpected call\n");
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI Pin_NewSegment(IPin *iface, REFERENCE_TIME tStart,
 905         REFERENCE_TIME tStop, double dRate)
 906 {
 907     ok(0, "unexpected call\n");
 908     return E_NOTIMPL;
 909 }
 910
 911 static const IPinVtbl PinVtbl = {
 912     Pin_QueryInterface,
 913     Pin_AddRef,
 914     Pin_Release,
 915     Pin_Connect,
 916     Pin_ReceiveConnection,
 917     Pin_Disconnect,
 918     Pin_ConnectedTo,
 919     Pin_ConnectionMediaType,
 920     Pin_QueryPinInfo,
 921     Pin_QueryDirection,
 922     Pin_QueryId,
 923     Pin_QueryAccept,
 924     Pin_EnumMediaTypes,
 925     Pin_QueryInternalConnections,
 926     Pin_EndOfStream,
 927     Pin_BeginFlush,
 928     Pin_EndFlush,
 929     Pin_NewSegment
 930 };
 931
 932 static test_filter* impl_from_IKsPropertySet(IKsPropertySet *iface)
 933 {
 934     return CONTAINING_RECORD(iface, test_filter, IKsPropertySet_iface);
 935 }
 936
 937 static HRESULT WINAPI KsPropertySet_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
 938 {
 939     ok(0, "unexpected call\n");
 940     return E_NOTIMPL;
 941 }
 942
 943 static ULONG WINAPI KsPropertySet_AddRef(IKsPropertySet *iface)
 944 {
 945     return 2;
 946 }
 947
 948 static ULONG WINAPI KsPropertySet_Release(IKsPropertySet *iface)
 949 {
 950     return 1;
 951 }
 952
 953 static HRESULT WINAPI KsPropertySet_Set(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID,
 954         LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData)
 955 {
 956     ok(0, "unexpected call\n");
 957     return E_NOTIMPL;
 958 }
 959
 960 static HRESULT WINAPI KsPropertySet_Get(IKsPropertySet *iface, REFGUID guidPropSet, DWORD dwPropID,
 961         LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned)
 962 {
 963     test_filter *This = impl_from_IKsPropertySet(iface);
 964     check_calls_list("KsPropertySet_Get", KSPROPERTYSET_GET, This->filter_type);
 965
 966     ok(IsEqualIID(guidPropSet, &AMPROPSETID_Pin), "guidPropSet = %s\n", wine_dbgstr_guid(guidPropSet));
 967     ok(dwPropID == 0, "dwPropID = %d\n", dwPropID);
 968     ok(pInstanceData == NULL, "pInstanceData != NULL\n");
 969     ok(cbInstanceData == 0, "cbInstanceData != 0\n");
 970     ok(cbPropData == sizeof(GUID), "cbPropData = %d\n", cbPropData);
 971     *pcbReturned = sizeof(GUID);
 972     memcpy(pPropData, &PIN_CATEGORY_EDS, sizeof(GUID));
 973     return S_OK;
 974 }
 975
 976 static HRESULT WINAPI KsPropertySet_QuerySupported(IKsPropertySet *iface,
 977         REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport)
 978 {
 979     ok(0, "unexpected call\n");
 980     return E_NOTIMPL;
 981 }
 982
 983 static const IKsPropertySetVtbl KsPropertySetVtbl = {
 984     KsPropertySet_QueryInterface,
 985     KsPropertySet_AddRef,
 986     KsPropertySet_Release,
 987     KsPropertySet_Set,
 988     KsPropertySet_Get,
 989     KsPropertySet_QuerySupported
 990 };
 991
 992 static IStream *avi_stream;
 993 static HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin *iface, REFIID riid, void **ppv)
 994 {
 995     if(IsEqualIID(riid, &IID_IStream)) {
 996         CHECK_EXPECT(MemInputPin_QueryInterface_IStream);
 997
 998         if(!avi_stream)
 999             return E_NOINTERFACE;
1000
1001         *ppv = avi_stream;
1002         IStream_AddRef(avi_stream);
1003         return S_OK;
1004     }
1005
1006     ok(0, "unexpected call: %s\n", wine_dbgstr_guid(riid));
1007     return E_NOTIMPL;
1008 }
1009
1010 static ULONG WINAPI MemInputPin_AddRef(IMemInputPin *iface)
1011 {
1012     return 2;
1013 }
1014
1015 static ULONG WINAPI MemInputPin_Release(IMemInputPin *iface)
1016 {
1017     return 1;
1018 }
1019
1020 static HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin *iface, IMemAllocator **ppAllocator)
1021 {
1022     ok(0, "unexpected call\n");
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin *iface,
1027         IMemAllocator *pAllocator, BOOL bReadOnly)
1028 {
1029     ALLOCATOR_PROPERTIES ap;
1030     HRESULT hr;
1031
1032     CHECK_EXPECT(NotifyAllocator);
1033
1034     ok(pAllocator != NULL, "pAllocator = %p\n", pAllocator);
1035     ok(bReadOnly, "bReadOnly = %x\n", bReadOnly);
1036
1037     hr = IMemAllocator_GetProperties(pAllocator, &ap);
1038     ok(hr == S_OK, "GetProperties returned %x\n", hr);
1039     ok(ap.cBuffers == 32, "cBuffers = %d\n", ap.cBuffers);
1040     ok(ap.cbBuffer == 0, "cbBuffer = %d\n", ap.cbBuffer);
1041     ok(ap.cbAlign == 1, "cbAlign = %d\n", ap.cbAlign);
1042     ok(ap.cbPrefix == 0, "cbPrefix = %d\n", ap.cbPrefix);
1043     return S_OK;
1044 }
1045
1046 static HRESULT WINAPI MemInputPin_GetAllocatorRequirements(
1047         IMemInputPin *iface, ALLOCATOR_PROPERTIES *pProps)
1048 {
1049     CHECK_EXPECT(GetAllocatorRequirements);
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI MemInputPin_Receive(IMemInputPin *iface, IMediaSample *pSample)
1054 {
1055     REFERENCE_TIME off, tmp;
1056     LARGE_INTEGER li;
1057     BYTE *data;
1058     HRESULT hr;
1059
1060     hr = IMediaSample_GetTime(pSample, &off, &tmp);
1061     ok(hr == S_OK, "got 0x%08x\n", hr);
1062     hr = IMediaSample_GetPointer(pSample, &data);
1063     ok(hr == S_OK, "got 0x%08x\n", hr);
1064     li.QuadPart = off;
1065     IStream_Seek(avi_stream, li, STREAM_SEEK_SET, NULL);
1066     IStream_Write(avi_stream, data, IMediaSample_GetActualDataLength(pSample), NULL);
1067     return S_OK;
1068 }
1069
1070 static HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin *iface,
1071         IMediaSample **pSamples, LONG nSamples, LONG *nSamplesProcessed)
1072 {
1073     ok(0, "unexpected call\n");
1074     return E_NOTIMPL;
1075 }
1076
1077 static HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin *iface)
1078 {
1079     ok(0, "unexpected call\n");
1080     return E_NOTIMPL;
1081 }
1082
1083 static const IMemInputPinVtbl MemInputPinVtbl = {
1084     MemInputPin_QueryInterface,
1085     MemInputPin_AddRef,
1086     MemInputPin_Release,
1087     MemInputPin_GetAllocator,
1088     MemInputPin_NotifyAllocator,
1089     MemInputPin_GetAllocatorRequirements,
1090     MemInputPin_Receive,
1091     MemInputPin_ReceiveMultiple,
1092     MemInputPin_ReceiveCanBlock
1093 };
1094
1095 static HRESULT WINAPI MediaSeeking_QueryInterface(
1096         IMediaSeeking *iface, REFIID riid, void **ppv)
1097 {
1098     ok(0, "unexpected call\n");
1099     return E_NOTIMPL;
1100 }
1101
1102 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
1103 {
1104     return 2;
1105 }
1106
1107 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
1108 {
1109     return 1;
1110 }
1111
1112 static HRESULT WINAPI MediaSeeking_GetCapabilities(
1113         IMediaSeeking *iface, DWORD *pCapabilities)
1114 {
1115     ok(0, "unexpected call\n");
1116     return E_NOTIMPL;
1117 }
1118
1119 static HRESULT WINAPI MediaSeeking_CheckCapabilities(
1120         IMediaSeeking *iface, DWORD *pCapabilities)
1121 {
1122     ok(0, "unexpected call\n");
1123     return E_NOTIMPL;
1124 }
1125
1126 static HRESULT WINAPI MediaSeeking_IsFormatSupported(
1127         IMediaSeeking *iface, const GUID *pFormat)
1128 {
1129     ok(0, "unexpected call\n");
1130     return E_NOTIMPL;
1131 }
1132
1133 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(
1134         IMediaSeeking *iface, GUID *pFormat)
1135 {
1136     ok(0, "unexpected call\n");
1137     return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI MediaSeeking_GetTimeFormat(
1141         IMediaSeeking *iface, GUID *pFormat)
1142 {
1143     ok(0, "unexpected call\n");
1144     return E_NOTIMPL;
1145 }
1146
1147 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(
1148         IMediaSeeking *iface, const GUID *pFormat)
1149 {
1150     ok(0, "unexpected call\n");
1151     return E_NOTIMPL;
1152 }
1153
1154 static HRESULT WINAPI MediaSeeking_SetTimeFormat(
1155         IMediaSeeking *iface, const GUID *pFormat)
1156 {
1157     ok(0, "unexpected call\n");
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI MediaSeeking_GetDuration(
1162         IMediaSeeking *iface, LONGLONG *pDuration)
1163 {
1164     ok(0, "unexpected call\n");
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI MediaSeeking_GetStopPosition(
1169         IMediaSeeking *iface, LONGLONG *pStop)
1170 {
1171     ok(0, "unexpected call\n");
1172     return E_NOTIMPL;
1173 }
1174
1175 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(
1176         IMediaSeeking *iface, LONGLONG *pCurrent)
1177 {
1178     ok(0, "unexpected call\n");
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget,
1183         const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
1184 {
1185     ok(0, "unexpected call\n");
1186     return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
1190         DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags)
1191 {
1192     ok(0, "unexpected call\n");
1193     return E_NOTIMPL;
1194 }
1195
1196 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface,
1197         LONGLONG *pCurrent, LONGLONG *pStop)
1198 {
1199     CHECK_EXPECT(MediaSeeking_GetPositions);
1200     return E_NOTIMPL;
1201 }
1202
1203 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface,
1204         LONGLONG *pEarliest, LONGLONG *pLatest)
1205 {
1206     ok(0, "unexpected call\n");
1207     return E_NOTIMPL;
1208 }
1209
1210 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
1211 {
1212     ok(0, "unexpected call\n");
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
1217 {
1218     ok(0, "unexpected call\n");
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
1223 {
1224     ok(0, "unexpected call\n");
1225     return E_NOTIMPL;
1226 }
1227
1228 static const IMediaSeekingVtbl MediaSeekingVtbl = {
1229     MediaSeeking_QueryInterface,
1230     MediaSeeking_AddRef,
1231     MediaSeeking_Release,
1232     MediaSeeking_GetCapabilities,
1233     MediaSeeking_CheckCapabilities,
1234     MediaSeeking_IsFormatSupported,
1235     MediaSeeking_QueryPreferredFormat,
1236     MediaSeeking_GetTimeFormat,
1237     MediaSeeking_IsUsingTimeFormat,
1238     MediaSeeking_SetTimeFormat,
1239     MediaSeeking_GetDuration,
1240     MediaSeeking_GetStopPosition,
1241     MediaSeeking_GetCurrentPosition,
1242     MediaSeeking_ConvertTimeFormat,
1243     MediaSeeking_SetPositions,
1244     MediaSeeking_GetPositions,
1245     MediaSeeking_GetAvailable,
1246     MediaSeeking_SetRate,
1247     MediaSeeking_GetRate,
1248     MediaSeeking_GetPreroll
1249 };
1250
1251 static test_filter* impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
1252 {
1253     return CONTAINING_RECORD(iface, test_filter, IEnumMediaTypes_iface);
1254 }
1255
1256 static HRESULT WINAPI EnumMediaTypes_QueryInterface(IEnumMediaTypes *iface, REFIID riid, void **ppv)
1257 {
1258     ok(0, "unexpected call\n");
1259     return E_NOTIMPL;
1260 }
1261
1262 static ULONG WINAPI EnumMediaTypes_AddRef(IEnumMediaTypes *iface)
1263 {
1264     return 2;
1265 }
1266
1267 static ULONG WINAPI EnumMediaTypes_Release(IEnumMediaTypes *iface)
1268 {
1269     return 1;
1270 }
1271
1272 static HRESULT WINAPI EnumMediaTypes_Next(IEnumMediaTypes *iface, ULONG cMediaTypes,
1273         AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched)
1274 {
1275     test_filter *This = impl_from_IEnumMediaTypes(iface);
1276     check_calls_list("EnumMediaTypes_Next", ENUMMEDIATYPES_NEXT, This->filter_type);
1277
1278     ok(cMediaTypes == 1, "cMediaTypes = %d\n", cMediaTypes);
1279     ok(ppMediaTypes != NULL, "ppMediaTypes == NULL\n");
1280     ok(pcFetched != NULL, "pcFetched == NULL\n");
1281
1282     if(!This->enum_media_types_pos++) {
1283         ppMediaTypes[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
1284         memset(ppMediaTypes[0], 0, sizeof(AM_MEDIA_TYPE));
1285         ppMediaTypes[0]->majortype = MEDIATYPE_Video;
1286         *pcFetched = 1;
1287         return S_OK;
1288     }
1289
1290     *pcFetched = 0;
1291     return S_FALSE;
1292 }
1293
1294 static HRESULT WINAPI EnumMediaTypes_Skip(IEnumMediaTypes *iface, ULONG cMediaTypes)
1295 {
1296     ok(0, "unexpected call\n");
1297     return E_NOTIMPL;
1298 }
1299
1300 static HRESULT WINAPI EnumMediaTypes_Reset(IEnumMediaTypes *iface)
1301 {
1302     test_filter *This = impl_from_IEnumMediaTypes(iface);
1303     check_calls_list("EnumMediaTypes_Reset", ENUMMEDIATYPES_RESET, This->filter_type);
1304
1305     This->enum_media_types_pos = 0;
1306     return S_OK;
1307 }
1308
1309 static HRESULT WINAPI EnumMediaTypes_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **ppEnum)
1310 {
1311     ok(0, "unexpected call\n");
1312     return E_NOTIMPL;
1313 }
1314
1315 static const IEnumMediaTypesVtbl EnumMediaTypesVtbl = {
1316     EnumMediaTypes_QueryInterface,
1317     EnumMediaTypes_AddRef,
1318     EnumMediaTypes_Release,
1319     EnumMediaTypes_Next,
1320     EnumMediaTypes_Skip,
1321     EnumMediaTypes_Reset,
1322     EnumMediaTypes_Clone
1323 };
1324
1325 static void init_test_filter(test_filter *This, PIN_DIRECTION dir, filter_type type)
1326 {
1327     memset(This, 0, sizeof(*This));
1328     This->IBaseFilter_iface.lpVtbl = &BaseFilterVtbl;
1329     This->IEnumPins_iface.lpVtbl = &EnumPinsVtbl;
1330     This->IPin_iface.lpVtbl = &PinVtbl;
1331     This->IKsPropertySet_iface.lpVtbl = &KsPropertySetVtbl;
1332     This->IMemInputPin_iface.lpVtbl = &MemInputPinVtbl;
1333     This->IMediaSeeking_iface.lpVtbl = &MediaSeekingVtbl;
1334     This->IEnumMediaTypes_iface.lpVtbl = &EnumMediaTypesVtbl;
1335
1336     This->dir = dir;
1337     This->filter_type = type;
1338 }
1339
1340 static void test_CaptureGraphBuilder_RenderStream(void)
1341 {
1342     test_filter source_filter, sink_filter, intermediate_filter;
1343     ICaptureGraphBuilder2 *cgb;
1344     HRESULT hr;
1345
1346     init_test_filter(&source_filter, PINDIR_OUTPUT, SOURCE_FILTER);
1347     init_test_filter(&sink_filter, PINDIR_INPUT, SINK_FILTER);
1348     init_test_filter(&intermediate_filter, PINDIR_OUTPUT, INTERMEDIATE_FILTER);
1349
1350     hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
1351             &IID_ICaptureGraphBuilder2, (void**)&cgb);
1352     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1353             "couldn't create CaptureGraphBuilder, hr = %08x\n", hr);
1354     if(hr != S_OK) {
1355         win_skip("CaptureGraphBuilder is not registered\n");
1356         return;
1357     }
1358
1359     hr = ICaptureGraphBuilder2_SetFiltergraph(cgb, &GraphBuilder);
1360     ok(hr == S_OK, "SetFiltergraph failed: %08x\n", hr);
1361
1362     trace("RenderStream with category and mediatype test\n");
1363     current_calls_list = renderstream_cat_media;
1364     call_no = 0;
1365     hr = ICaptureGraphBuilder2_RenderStream(cgb, &PIN_CATEGORY_EDS,
1366             &MEDIATYPE_Video, (IUnknown*)&source_filter.IBaseFilter_iface,
1367             NULL, &sink_filter.IBaseFilter_iface);
1368     ok(hr == S_OK, "RenderStream failed: %08x\n", hr);
1369     check_calls_list("test_CaptureGraphBuilder_RenderStream", END, NOT_FILTER);
1370
1371     trace("RenderStream with intermediate filter\n");
1372     current_calls_list = renderstream_intermediate;
1373     call_no = 0;
1374     hr = ICaptureGraphBuilder2_RenderStream(cgb, &PIN_CATEGORY_EDS,
1375             &MEDIATYPE_Video, (IUnknown*)&source_filter.IBaseFilter_iface,
1376             &intermediate_filter.IBaseFilter_iface, &sink_filter.IBaseFilter_iface);
1377     ok(hr == S_OK, "RenderStream failed: %08x\n", hr);
1378     check_calls_list("test_CaptureGraphBuilder_RenderStream", END, NOT_FILTER);
1379
1380     ICaptureGraphBuilder2_Release(cgb);
1381 }
1382
1383 static void test_AviMux_QueryInterface(void)
1384 {
1385     IUnknown *avimux, *unk;
1386     HRESULT hr;
1387
1388     hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&avimux);
1389     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1390             "couldn't create AVI Mux filter, hr = %08x\n", hr);
1391     if(hr != S_OK) {
1392         win_skip("AVI Mux filter is not registered\n");
1393         return;
1394     }
1395
1396     hr = IUnknown_QueryInterface(avimux, &IID_IBaseFilter, (void**)&unk);
1397     ok(hr == S_OK, "QueryInterface(IID_IBaseFilter) failed: %x\n", hr);
1398     IUnknown_Release(unk);
1399
1400     hr = IUnknown_QueryInterface(avimux, &IID_IConfigAviMux, (void**)&unk);
1401     ok(hr == S_OK, "QueryInterface(IID_IConfigAviMux) failed: %x\n", hr);
1402     IUnknown_Release(unk);
1403
1404     hr = IUnknown_QueryInterface(avimux, &IID_IConfigInterleaving, (void**)&unk);
1405     ok(hr == S_OK, "QueryInterface(IID_IConfigInterleaving) failed: %x\n", hr);
1406     IUnknown_Release(unk);
1407
1408     hr = IUnknown_QueryInterface(avimux, &IID_IMediaSeeking, (void**)&unk);
1409     ok(hr == S_OK, "QueryInterface(IID_IMediaSeeking) failed: %x\n", hr);
1410     IUnknown_Release(unk);
1411
1412     hr = IUnknown_QueryInterface(avimux, &IID_IPersistMediaPropertyBag, (void**)&unk);
1413     ok(hr == S_OK, "QueryInterface(IID_IPersistMediaPropertyBag) failed: %x\n", hr);
1414     IUnknown_Release(unk);
1415
1416     hr = IUnknown_QueryInterface(avimux, &IID_ISpecifyPropertyPages, (void**)&unk);
1417     ok(hr == S_OK, "QueryInterface(IID_ISpecifyPropertyPages) failed: %x\n", hr);
1418     IUnknown_Release(unk);
1419
1420     IUnknown_Release(avimux);
1421 }
1422
1423 static HRESULT WINAPI MemAllocator_QueryInterface(IMemAllocator *iface, REFIID riid, void **ppvObject)
1424 {
1425     if(IsEqualIID(riid, &IID_IUnknown)) {
1426         *ppvObject = iface;
1427         return S_OK;
1428     }
1429
1430     ok(0, "unexpected call: %s\n", wine_dbgstr_guid(riid));
1431     return E_NOTIMPL;
1432 }
1433
1434 static ULONG WINAPI MemAllocator_AddRef(IMemAllocator *iface)
1435 {
1436     return 2;
1437 }
1438
1439 static ULONG WINAPI MemAllocator_Release(IMemAllocator *iface)
1440 {
1441     return 1;
1442 }
1443
1444 static HRESULT WINAPI MemAllocator_SetProperties(IMemAllocator *iface,
1445         ALLOCATOR_PROPERTIES *pRequest, ALLOCATOR_PROPERTIES *pActual)
1446 {
1447     ok(0, "unexpected call\n");
1448     return E_NOTIMPL;
1449 }
1450
1451 static HRESULT WINAPI MemAllocator_GetProperties(IMemAllocator *iface, ALLOCATOR_PROPERTIES *pProps)
1452 {
1453     CHECK_EXPECT2(MemAllocator_GetProperties);
1454
1455     pProps->cBuffers = 1;
1456     pProps->cbBuffer = 1024;
1457     pProps->cbAlign = 0;
1458     pProps->cbPrefix = 0;
1459     return S_OK;
1460 }
1461
1462 static HRESULT WINAPI MemAllocator_Commit(IMemAllocator *iface)
1463 {
1464     ok(0, "unexpected call\n");
1465     return E_NOTIMPL;
1466 }
1467
1468 static HRESULT WINAPI MemAllocator_Decommit(IMemAllocator *iface)
1469 {
1470     ok(0, "unexpected call\n");
1471     return E_NOTIMPL;
1472 }
1473
1474 static HRESULT WINAPI MemAllocator_GetBuffer(IMemAllocator *iface, IMediaSample **ppBuffer,
1475         REFERENCE_TIME *pStartTime, REFERENCE_TIME *pEndTime, DWORD dwFlags)
1476 {
1477     ok(0, "unexpected call\n");
1478     return E_NOTIMPL;
1479 }
1480
1481 static HRESULT WINAPI MemAllocator_ReleaseBuffer(IMemAllocator *iface, IMediaSample *pBuffer)
1482 {
1483     ok(0, "unexpected call\n");
1484     return E_NOTIMPL;
1485 }
1486
1487 static const IMemAllocatorVtbl MemAllocatorVtbl = {
1488     MemAllocator_QueryInterface,
1489     MemAllocator_AddRef,
1490     MemAllocator_Release,
1491     MemAllocator_SetProperties,
1492     MemAllocator_GetProperties,
1493     MemAllocator_Commit,
1494     MemAllocator_Decommit,
1495     MemAllocator_GetBuffer,
1496     MemAllocator_ReleaseBuffer
1497 };
1498 IMemAllocator MemAllocator = {&MemAllocatorVtbl};
1499
1500 static HRESULT WINAPI MediaSample_QueryInterface(IMediaSample* This, REFIID riid, void **ppv)
1501 {
1502     if(IsEqualIID(riid, &IID_IMediaSample2))
1503         CHECK_EXPECT(MediaSample_QueryInterface_MediaSample2);
1504     else
1505         ok(0, "MediaSample_QueryInterface: %s\n", wine_dbgstr_guid(riid));
1506
1507     *ppv = NULL;
1508     return E_NOINTERFACE;
1509 }
1510
1511 static ULONG WINAPI MediaSample_AddRef(IMediaSample* This)
1512 {
1513     return 2;
1514 }
1515
1516 static ULONG WINAPI MediaSample_Release(IMediaSample* This)
1517 {
1518     return 1;
1519 }
1520
1521 static BYTE buf[1024];
1522 static HRESULT WINAPI MediaSample_GetPointer(IMediaSample* This, BYTE **ppBuffer)
1523 {
1524     CHECK_EXPECT2(MediaSample_GetPointer);
1525     *ppBuffer = buf;
1526     memset(buf, 'z', sizeof(buf));
1527     return S_OK;
1528 }
1529
1530 static LONG WINAPI MediaSample_GetSize(IMediaSample* This)
1531 {
1532     CHECK_EXPECT2(MediaSample_GetSize);
1533     return sizeof(buf);
1534 }
1535
1536 static REFERENCE_TIME start_time, end_time;
1537 static HRESULT WINAPI MediaSample_GetTime(IMediaSample* This,
1538         REFERENCE_TIME *pTimeStart, REFERENCE_TIME *pTimeEnd)
1539 {
1540     CHECK_EXPECT2(MediaSample_GetTime);
1541     *pTimeStart = start_time;
1542     *pTimeEnd = end_time;
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI MediaSample_SetTime(IMediaSample* This,
1547         REFERENCE_TIME *pTimeStart, REFERENCE_TIME *pTimeEnd)
1548 {
1549     ok(0, "unexpected call\n");
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI MediaSample_IsSyncPoint(IMediaSample* This)
1554 {
1555     CHECK_EXPECT2(MediaSample_IsSyncPoint);
1556     return S_OK;
1557 }
1558
1559 static HRESULT WINAPI MediaSample_SetSyncPoint(IMediaSample* This, BOOL bIsSyncPoint)
1560 {
1561     ok(0, "unexpected call\n");
1562     return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI MediaSample_IsPreroll(IMediaSample* This)
1566 {
1567     CHECK_EXPECT2(MediaSample_IsPreroll);
1568     return S_FALSE;
1569 }
1570
1571 static HRESULT WINAPI MediaSample_SetPreroll(IMediaSample* This, BOOL bIsPreroll)
1572 {
1573     ok(0, "unexpected call\n");
1574     return E_NOTIMPL;
1575 }
1576
1577 static LONG WINAPI MediaSample_GetActualDataLength(IMediaSample* This)
1578 {
1579     CHECK_EXPECT2(MediaSample_GetActualDataLength);
1580     return sizeof(buf);
1581 }
1582
1583 static HRESULT WINAPI MediaSample_SetActualDataLength(IMediaSample* This, LONG length)
1584 {
1585     ok(0, "unexpected call\n");
1586     return E_NOTIMPL;
1587 }
1588
1589 static HRESULT WINAPI MediaSample_GetMediaType(IMediaSample* This, AM_MEDIA_TYPE **ppMediaType)
1590 {
1591     CHECK_EXPECT2(MediaSample_GetMediaType);
1592     *ppMediaType = NULL;
1593     return S_FALSE;
1594 }
1595
1596 static HRESULT WINAPI MediaSample_SetMediaType(IMediaSample* This, AM_MEDIA_TYPE *pMediaType)
1597 {
1598     ok(0, "unexpected call\n");
1599     return E_NOTIMPL;
1600 }
1601
1602 static HRESULT WINAPI MediaSample_IsDiscontinuity(IMediaSample* This)
1603 {
1604     CHECK_EXPECT(MediaSample_IsDiscontinuity);
1605     return S_FALSE;
1606 }
1607
1608 static HRESULT WINAPI MediaSample_SetDiscontinuity(IMediaSample* This, BOOL bDiscontinuity)
1609 {
1610     ok(0, "unexpected call\n");
1611     return E_NOTIMPL;
1612 }
1613
1614 static HRESULT WINAPI MediaSample_GetMediaTime(IMediaSample* This,
1615         LONGLONG *pTimeStart, LONGLONG *pTimeEnd)
1616 {
1617     CHECK_EXPECT(MediaSample_GetMediaTime);
1618     return E_NOTIMPL;
1619 }
1620
1621 static HRESULT WINAPI MediaSample_SetMediaTime(IMediaSample* This,
1622         LONGLONG *pTimeStart, LONGLONG *pTimeEnd)
1623 {
1624     ok(0, "unexpected call\n");
1625     return E_NOTIMPL;
1626 }
1627
1628 static const IMediaSampleVtbl MediaSampleVtbl = {
1629     MediaSample_QueryInterface,
1630     MediaSample_AddRef,
1631     MediaSample_Release,
1632     MediaSample_GetPointer,
1633     MediaSample_GetSize,
1634     MediaSample_GetTime,
1635     MediaSample_SetTime,
1636     MediaSample_IsSyncPoint,
1637     MediaSample_SetSyncPoint,
1638     MediaSample_IsPreroll,
1639     MediaSample_SetPreroll,
1640     MediaSample_GetActualDataLength,
1641     MediaSample_SetActualDataLength,
1642     MediaSample_GetMediaType,
1643     MediaSample_SetMediaType,
1644     MediaSample_IsDiscontinuity,
1645     MediaSample_SetDiscontinuity,
1646     MediaSample_GetMediaTime,
1647     MediaSample_SetMediaTime,
1648 };
1649 IMediaSample MediaSample = {&MediaSampleVtbl};
1650
1651 static void test_AviMux(char *arg)
1652 {
1653     test_filter source_filter, sink_filter;
1654     VIDEOINFO videoinfo;
1655     IPin *avimux_in, *avimux_out, *pin;
1656     AM_MEDIA_TYPE source_media_type;
1657     AM_MEDIA_TYPE *media_type;
1658     PIN_DIRECTION dir;
1659     IBaseFilter *avimux;
1660     IEnumPins *ep;
1661     IEnumMediaTypes *emt;
1662     IMemInputPin *memin;
1663     ALLOCATOR_PROPERTIES props;
1664     IMemAllocator *memalloc;
1665     IConfigInterleaving *ci;
1666     FILTER_STATE state;
1667     HRESULT hr;
1668     ULONG ref;
1669
1670     init_test_filter(&source_filter, PINDIR_OUTPUT, SOURCE_FILTER);
1671     init_test_filter(&sink_filter, PINDIR_INPUT, SINK_FILTER);
1672
1673     hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void**)&avimux);
1674     ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG),
1675             "couldn't create AVI Mux filter, hr = %08x\n", hr);
1676     if(hr != S_OK) {
1677         win_skip("AVI Mux filter is not registered\n");
1678         return;
1679     }
1680
1681     hr = IBaseFilter_EnumPins(avimux, &ep);
1682     ok(hr == S_OK, "EnumPins returned %x\n", hr);
1683
1684     hr = IEnumPins_Next(ep, 1, &avimux_out, NULL);
1685     ok(hr == S_OK, "Next returned %x\n", hr);
1686     hr = IPin_QueryDirection(avimux_out, &dir);
1687     ok(hr == S_OK, "QueryDirection returned %x\n", hr);
1688     ok(dir == PINDIR_OUTPUT, "dir = %d\n", dir);
1689
1690     hr = IEnumPins_Next(ep, 1, &avimux_in, NULL);
1691     ok(hr == S_OK, "Next returned %x\n", hr);
1692     hr = IPin_QueryDirection(avimux_in, &dir);
1693     ok(hr == S_OK, "QueryDirection returned %x\n", hr);
1694     ok(dir == PINDIR_INPUT, "dir = %d\n", dir);
1695     IEnumPins_Release(ep);
1696
1697     hr = IPin_EnumMediaTypes(avimux_out, &emt);
1698     ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr);
1699     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1700     ok(hr == S_OK, "Next returned %x\n", hr);
1701     ok(IsEqualIID(&media_type->majortype, &MEDIATYPE_Stream), "majortype = %s\n",
1702             wine_dbgstr_guid(&media_type->majortype));
1703     ok(IsEqualIID(&media_type->subtype, &MEDIASUBTYPE_Avi), "subtype = %s\n",
1704             wine_dbgstr_guid(&media_type->subtype));
1705     ok(media_type->bFixedSizeSamples, "bFixedSizeSamples = %x\n", media_type->bFixedSizeSamples);
1706     ok(!media_type->bTemporalCompression, "bTemporalCompression = %x\n", media_type->bTemporalCompression);
1707     ok(media_type->lSampleSize == 1, "lSampleSize = %d\n", media_type->lSampleSize);
1708     ok(IsEqualIID(&media_type->formattype, &GUID_NULL), "formattype = %s\n",
1709             wine_dbgstr_guid(&media_type->formattype));
1710     ok(!media_type->pUnk, "pUnk = %p\n", media_type->pUnk);
1711     ok(!media_type->cbFormat, "cbFormat = %d\n", media_type->cbFormat);
1712     ok(!media_type->pbFormat, "pbFormat = %p\n", media_type->pbFormat);
1713     CoTaskMemFree(media_type);
1714     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1715     ok(hr == S_FALSE, "Next returned %x\n", hr);
1716     IEnumMediaTypes_Release(emt);
1717
1718     hr = IPin_EnumMediaTypes(avimux_in, &emt);
1719     ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr);
1720     hr = IEnumMediaTypes_Reset(emt);
1721     ok(hr == S_OK, "Reset returned %x\n", hr);
1722     hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL);
1723     ok(hr == S_FALSE, "Next returned %x\n", hr);
1724     IEnumMediaTypes_Release(emt);
1725
1726     hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, NULL);
1727     ok(hr == E_POINTER, "ReceiveConnection returned %x\n", hr);
1728
1729     current_calls_list = NULL;
1730     memset(&source_media_type, 0, sizeof(AM_MEDIA_TYPE));
1731     memset(&videoinfo, 0, sizeof(VIDEOINFO));
1732     source_media_type.majortype = MEDIATYPE_Video;
1733     source_media_type.subtype = MEDIASUBTYPE_RGB32;
1734     source_media_type.formattype = FORMAT_VideoInfo;
1735     source_media_type.bFixedSizeSamples = TRUE;
1736     source_media_type.lSampleSize = 40000;
1737     source_media_type.cbFormat = sizeof(VIDEOINFO);
1738     source_media_type.pbFormat = (BYTE*)&videoinfo;
1739     videoinfo.AvgTimePerFrame = 333333;
1740     videoinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1741     videoinfo.bmiHeader.biWidth = 100;
1742     videoinfo.bmiHeader.biHeight = 100;
1743     videoinfo.bmiHeader.biPlanes = 1;
1744     videoinfo.bmiHeader.biBitCount = 32;
1745     videoinfo.bmiHeader.biSizeImage = 40000;
1746     videoinfo.bmiHeader.biClrImportant = 256;
1747     hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, &source_media_type);
1748     ok(hr == S_OK, "ReceiveConnection returned %x\n", hr);
1749
1750     hr = IPin_ConnectedTo(avimux_in, &pin);
1751     ok(hr == S_OK, "ConnectedTo returned %x\n", hr);
1752     ok(pin == &source_filter.IPin_iface, "incorrect pin: %p, expected %p\n",
1753             pin, &source_filter.IPin_iface);
1754
1755     hr = IPin_Connect(avimux_out, &source_filter.IPin_iface, NULL);
1756     todo_wine ok(hr == VFW_E_INVALID_DIRECTION, "Connect returned %x\n", hr);
1757
1758     hr = IBaseFilter_JoinFilterGraph(avimux, (IFilterGraph*)&GraphBuilder, NULL);
1759     ok(hr == S_OK, "JoinFilterGraph returned %x\n", hr);
1760
1761     SET_EXPECT(ReceiveConnection);
1762     SET_EXPECT(GetAllocatorRequirements);
1763     SET_EXPECT(NotifyAllocator);
1764     SET_EXPECT(Reconnect);
1765     hr = IPin_Connect(avimux_out, &sink_filter.IPin_iface, NULL);
1766     ok(hr == S_OK, "Connect returned %x\n", hr);
1767     CHECK_CALLED(ReceiveConnection);
1768     CHECK_CALLED(GetAllocatorRequirements);
1769     CHECK_CALLED(NotifyAllocator);
1770     CHECK_CALLED(Reconnect);
1771
1772     hr = IPin_ConnectedTo(avimux_out, &pin);
1773     ok(hr == S_OK, "ConnectedTo returned %x\n", hr);
1774     ok(pin == &sink_filter.IPin_iface, "incorrect pin: %p, expected %p\n",
1775             pin, &source_filter.IPin_iface);
1776
1777     hr = IPin_QueryInterface(avimux_in, &IID_IMemInputPin, (void**)&memin);
1778     ok(hr == S_OK, "QueryInterface returned %x\n", hr);
1779
1780     props.cBuffers = 0xdeadbee1;
1781     props.cbBuffer = 0xdeadbee2;
1782     props.cbAlign = 0xdeadbee3;
1783     props.cbPrefix = 0xdeadbee4;
1784     hr = IMemInputPin_GetAllocatorRequirements(memin, &props);
1785     ok(hr==S_OK || broken(hr==E_INVALIDARG), "GetAllocatorRequirments returned %x\n", hr);
1786     if(hr == S_OK) {
1787         ok(props.cBuffers == 0xdeadbee1, "cBuffers = %d\n", props.cBuffers);
1788         ok(props.cbBuffer == 0xdeadbee2, "cbBuffer = %d\n", props.cbBuffer);
1789         ok(props.cbAlign == 1, "cbAlign = %d\n", props.cbAlign);
1790         ok(props.cbPrefix == 8, "cbPrefix = %d\n", props.cbPrefix);
1791     }
1792
1793     hr = IMemInputPin_GetAllocator(memin, &memalloc);
1794     ok(hr == S_OK, "GetAllocator returned %x\n", hr);
1795
1796     props.cBuffers = 0xdeadbee1;
1797     props.cbBuffer = 0xdeadbee2;
1798     props.cbAlign = 0xdeadbee3;
1799     props.cbPrefix = 0xdeadbee4;
1800     hr = IMemAllocator_GetProperties(memalloc, &props);
1801     ok(hr == S_OK, "GetProperties returned %x\n", hr);
1802     ok(props.cBuffers == 0, "cBuffers = %d\n", props.cBuffers);
1803     ok(props.cbBuffer == 0, "cbBuffer = %d\n", props.cbBuffer);
1804     ok(props.cbAlign == 0, "cbAlign = %d\n", props.cbAlign);
1805     ok(props.cbPrefix == 0, "cbPrefix = %d\n", props.cbPrefix);
1806     IMemAllocator_Release(memalloc);
1807
1808     hr = IBaseFilter_QueryInterface(avimux, &IID_IConfigInterleaving, (void**)&ci);
1809     ok(hr == S_OK, "QueryInterface(IID_IConfigInterleaving) returned %x\n", hr);
1810     hr = IConfigInterleaving_put_Mode(ci, 5);
1811     ok(hr == E_INVALIDARG, "put_Mode returned %x\n", hr);
1812     SET_EXPECT(Reconnect);
1813     hr = IConfigInterleaving_put_Mode(ci, INTERLEAVE_FULL);
1814     ok(hr == S_OK, "put_Mode returned %x\n", hr);
1815     CHECK_CALLED(Reconnect);
1816     IConfigInterleaving_Release(ci);
1817
1818     hr = IBaseFilter_GetState(avimux, 0, &state);
1819     ok(hr == S_OK, "GetState returned %x\n", hr);
1820     ok(state == State_Stopped, "state = %d\n", state);
1821
1822     SET_EXPECT(MemAllocator_GetProperties);
1823     hr = IMemInputPin_NotifyAllocator(memin, &MemAllocator, TRUE);
1824     ok(hr == S_OK, "NotifyAllocator returned %x\n", hr);
1825     CHECK_CALLED(MemAllocator_GetProperties);
1826
1827     hr = IMemInputPin_GetAllocator(memin, &memalloc);
1828     ok(hr == S_OK, "GetAllocator returned %x\n", hr);
1829     ok(memalloc != &MemAllocator, "memalloc == &MemAllocator\n");
1830     IMemAllocator_Release(memalloc);
1831
1832     hr = CreateStreamOnHGlobal(NULL, TRUE, &avi_stream);
1833     ok(hr == S_OK, "got 0x%08x\n", hr);
1834     SET_EXPECT(MediaSeeking_GetPositions);
1835     SET_EXPECT(MemInputPin_QueryInterface_IStream);
1836     hr = IBaseFilter_Run(avimux, 0);
1837     ok(hr == S_OK, "Run returned %x\n", hr);
1838     CHECK_CALLED(MediaSeeking_GetPositions);
1839
1840     hr = IBaseFilter_GetState(avimux, 0, &state);
1841     ok(hr == S_OK, "GetState returned %x\n", hr);
1842     ok(state == State_Running, "state = %d\n", state);
1843
1844     SET_EXPECT(MediaSample_QueryInterface_MediaSample2);
1845     SET_EXPECT(MediaSample_IsDiscontinuity);
1846     SET_EXPECT(MediaSample_IsPreroll);
1847     SET_EXPECT(MediaSample_IsSyncPoint);
1848     SET_EXPECT(MediaSample_GetTime);
1849     SET_EXPECT(MediaSample_GetMediaType);
1850     SET_EXPECT(MediaSample_GetPointer);
1851     SET_EXPECT(MediaSample_GetActualDataLength);
1852     SET_EXPECT(MediaSample_GetSize);
1853     SET_EXPECT(MediaSample_GetMediaTime);
1854     start_time = end_time = 0;
1855     hr = IMemInputPin_Receive(memin, &MediaSample);
1856     ok(hr == S_OK, "Receive returned %x\n", hr);
1857     CHECK_CALLED(MediaSample_QueryInterface_MediaSample2);
1858     todo_wine CHECK_CALLED(MediaSample_IsDiscontinuity);
1859     todo_wine CHECK_CALLED(MediaSample_IsPreroll);
1860     CHECK_CALLED(MediaSample_IsSyncPoint);
1861     CHECK_CALLED(MediaSample_GetTime);
1862     todo_wine CHECK_CALLED(MediaSample_GetMediaType);
1863     CHECK_CALLED(MediaSample_GetPointer);
1864     CHECK_CALLED(MediaSample_GetActualDataLength);
1865     todo_wine CHECK_CALLED(MediaSample_GetSize);
1866     todo_wine CHECK_CALLED(MediaSample_GetMediaTime);
1867
1868     SET_EXPECT(MediaSample_QueryInterface_MediaSample2);
1869     SET_EXPECT(MediaSample_IsDiscontinuity);
1870     SET_EXPECT(MediaSample_IsPreroll);
1871     SET_EXPECT(MediaSample_IsSyncPoint);
1872     SET_EXPECT(MediaSample_GetTime);
1873     SET_EXPECT(MediaSample_GetMediaType);
1874     SET_EXPECT(MediaSample_GetPointer);
1875     SET_EXPECT(MediaSample_GetActualDataLength);
1876     SET_EXPECT(MediaSample_GetSize);
1877     SET_EXPECT(MediaSample_GetMediaTime);
1878     hr = IMemInputPin_Receive(memin, &MediaSample);
1879     ok(hr == S_OK, "Receive returned %x\n", hr);
1880     CHECK_CALLED(MediaSample_QueryInterface_MediaSample2);
1881     todo_wine CHECK_CALLED(MediaSample_IsDiscontinuity);
1882     todo_wine CHECK_CALLED(MediaSample_IsPreroll);
1883     CHECK_CALLED(MediaSample_IsSyncPoint);
1884     CHECK_CALLED(MediaSample_GetTime);
1885     todo_wine CHECK_CALLED(MediaSample_GetMediaType);
1886     CHECK_CALLED(MediaSample_GetPointer);
1887     CHECK_CALLED(MediaSample_GetActualDataLength);
1888     todo_wine CHECK_CALLED(MediaSample_GetSize);
1889     todo_wine CHECK_CALLED(MediaSample_GetMediaTime);
1890
1891     SET_EXPECT(MediaSample_QueryInterface_MediaSample2);
1892     SET_EXPECT(MediaSample_IsDiscontinuity);
1893     SET_EXPECT(MediaSample_IsPreroll);
1894     SET_EXPECT(MediaSample_IsSyncPoint);
1895     SET_EXPECT(MediaSample_GetTime);
1896     SET_EXPECT(MediaSample_GetMediaType);
1897     SET_EXPECT(MediaSample_GetPointer);
1898     SET_EXPECT(MediaSample_GetActualDataLength);
1899     SET_EXPECT(MediaSample_GetSize);
1900     SET_EXPECT(MediaSample_GetMediaTime);
1901     start_time = 20000000;
1902     end_time = 21000000;
1903     hr = IMemInputPin_Receive(memin, &MediaSample);
1904     ok(hr == S_OK, "Receive returned %x\n", hr);
1905     CHECK_CALLED(MediaSample_QueryInterface_MediaSample2);
1906     todo_wine CHECK_CALLED(MediaSample_IsDiscontinuity);
1907     todo_wine CHECK_CALLED(MediaSample_IsPreroll);
1908     CHECK_CALLED(MediaSample_IsSyncPoint);
1909     CHECK_CALLED(MediaSample_GetTime);
1910     todo_wine CHECK_CALLED(MediaSample_GetMediaType);
1911     CHECK_CALLED(MediaSample_GetPointer);
1912     CHECK_CALLED(MediaSample_GetActualDataLength);
1913     todo_wine CHECK_CALLED(MediaSample_GetSize);
1914     todo_wine CHECK_CALLED(MediaSample_GetMediaTime);
1915     IMemInputPin_Release(memin);
1916
1917     hr = IBaseFilter_Stop(avimux);
1918     ok(hr == S_OK, "Stop returned %x\n", hr);
1919     CHECK_CALLED(MemInputPin_QueryInterface_IStream);
1920
1921     hr = IBaseFilter_GetState(avimux, 0, &state);
1922     ok(hr == S_OK, "GetState returned %x\n", hr);
1923     ok(state == State_Stopped, "state = %d\n", state);
1924
1925     hr = IPin_Disconnect(avimux_out);
1926     ok(hr == S_OK, "Disconnect returned %x\n", hr);
1927
1928     IPin_Release(avimux_in);
1929     IPin_Release(avimux_out);
1930     ref = IBaseFilter_Release(avimux);
1931     ok(ref == 0, "Avi Mux filter was not destroyed (%d)\n", ref);
1932
1933     if(arg && !strcmp(arg, "save")) {
1934         LARGE_INTEGER li;
1935         char buf[1024];
1936         ULONG read;
1937         HANDLE *f;
1938
1939         f = CreateFileA("avimux.avi", GENERIC_WRITE, 0, NULL,
1940                 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1941         ok(f != INVALID_HANDLE_VALUE, "CreateFile failed\n");
1942
1943         li.QuadPart = 0;
1944         hr = IStream_Seek(avi_stream, li, STREAM_SEEK_SET, NULL);
1945         ok(hr == S_OK, "IStream_Seek failed: %x\n", hr);
1946
1947         while(1) {
1948             hr = IStream_Read(avi_stream, buf, sizeof(buf), &read);
1949             if(FAILED(hr)) {
1950                 ok(0, "IStream_Read failed: %x\n", hr);
1951                 break;
1952             }
1953             if(!read)
1954                 break;
1955             ok(WriteFile(f, buf, read, &read, NULL), "WriteFile failed\n");
1956             if(hr == S_FALSE)
1957                 break;
1958         }
1959         CloseHandle(f);
1960     }
1961
1962     ref = IStream_Release(avi_stream);
1963     ok(ref == 0, "IStream was not destroyed (%d)\n", ref);
1964 }
1965
1966 static HRESULT WINAPI PropertyBag_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
1967 {
1968     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IPropertyBag, riid)) {
1969         *ppv = iface;
1970         return S_OK;
1971     }
1972
1973     ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
1974     *ppv = NULL;
1975     return E_NOINTERFACE;
1976 }
1977
1978 static ULONG WINAPI PropertyBag_AddRef(IPropertyBag *iface)
1979 {
1980     return 2;
1981 }
1982
1983 static ULONG WINAPI PropertyBag_Release(IPropertyBag *iface)
1984 {
1985     return 1;
1986 }
1987
1988 static HRESULT WINAPI PropertyBag_Read(IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
1989 {
1990     ok(!pErrorLog, "pErrorLog = %p\n", pErrorLog);
1991
1992     if(!strcmp_wa(pszPropName, "FccHandler")) {
1993         CHECK_EXPECT(Read_FccHandler);
1994         V_VT(pVar) = VT_BSTR;
1995         V_BSTR(pVar) = a2bstr("mrle");
1996         return S_OK;
1997     }
1998
1999     ok(0, "unexpected call: %s\n", wine_dbgstr_w(pszPropName));
2000     return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI PropertyBag_Write(IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar)
2004 {
2005     ok(0, "unexpected call: %s\n", wine_dbgstr_w(pszPropName));
2006     return E_NOTIMPL;
2007 }
2008
2009 static const IPropertyBagVtbl PropertyBagVtbl = {
2010     PropertyBag_QueryInterface,
2011     PropertyBag_AddRef,
2012     PropertyBag_Release,
2013     PropertyBag_Read,
2014     PropertyBag_Write
2015 };
2016
2017 static IPropertyBag PropertyBag = { &PropertyBagVtbl };
2018
2019 static void test_AviCo(void)
2020 {
2021     IPersistPropertyBag *persist_bag;
2022     IPin *pin, *in_pin, *out_pin;
2023     IEnumPins *enum_pins;
2024     IBaseFilter *avico;
2025     PIN_INFO pin_info;
2026     HRESULT hres;
2027
2028     static const WCHAR inputW[] = {'I','n','p','u','t',0};
2029     static const WCHAR outputW[] = {'O','u','t','p','u','t',0};
2030
2031     hres = CoCreateInstance(&CLSID_AVICo, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void**)&avico);
2032     if(hres == REGDB_E_CLASSNOTREG) {
2033         win_skip("CLSID_AVICo not registered\n");
2034         return;
2035     }
2036     ok(hres == S_OK, "Could not create CLSID_AVICo class: %08x\n", hres);
2037
2038     hres = IBaseFilter_QueryInterface(avico, &IID_IPin, (void**)&pin);
2039     ok(hres == E_NOINTERFACE, "QueryInterface(IID_IPin) returned: %08x\n", hres);
2040
2041     hres = IBaseFilter_QueryInterface(avico, &IID_IPersistPropertyBag, (void**)&persist_bag);
2042     ok(hres == S_OK, "QueryInterface(IID_IPersistPropertyBag) returned: %08x\n", hres);
2043
2044     SET_EXPECT(Read_FccHandler);
2045     hres = IPersistPropertyBag_Load(persist_bag, &PropertyBag, NULL);
2046     ok(hres == S_OK, "Load failed: %08x\n", hres);
2047     CHECK_CALLED(Read_FccHandler);
2048
2049     IPersistPropertyBag_Release(persist_bag);
2050
2051     hres = IBaseFilter_EnumPins(avico, &enum_pins);
2052     ok(hres == S_OK, "EnumPins failed: %08x\n", hres);
2053
2054     hres = IEnumPins_Next(enum_pins, 1, &in_pin, NULL);
2055     ok(hres == S_OK, "Next failed: %08x\n", hres);
2056
2057     hres = IPin_QueryPinInfo(in_pin, &pin_info);
2058     ok(hres == S_OK, "QueryPinInfo failed: %08x\n", hres);
2059     ok(pin_info.pFilter == avico, "pin_info.pFilter != avico\n");
2060     ok(pin_info.dir == PINDIR_INPUT, "pin_info.dir = %d\n", pin_info.dir);
2061     ok(!lstrcmpW(pin_info.achName, inputW), "pin_info.achName = %s\n", wine_dbgstr_w(pin_info.achName));
2062
2063     hres = IEnumPins_Next(enum_pins, 1, &out_pin, NULL);
2064     ok(hres == S_OK, "Next failed: %08x\n", hres);
2065
2066     hres = IPin_QueryPinInfo(out_pin, &pin_info);
2067     ok(hres == S_OK, "QueryPinInfo failed: %08x\n", hres);
2068     ok(pin_info.pFilter == avico, "pin_info.pFilter != avico\n");
2069     ok(pin_info.dir == PINDIR_OUTPUT, "pin_info.dir = %d\n", pin_info.dir);
2070     ok(!lstrcmpW(pin_info.achName, outputW), "pin_info.achName = %s\n", wine_dbgstr_w(pin_info.achName));
2071
2072     IEnumPins_Release(enum_pins);
2073
2074     IPin_Release(in_pin);
2075     IPin_Release(out_pin);
2076     IBaseFilter_Release(avico);
2077 }
2078
2079 START_TEST(qcap)
2080 {
2081     if (SUCCEEDED(CoInitialize(NULL)))
2082     {
2083         int arg_c;
2084         char **arg_v;
2085
2086         arg_c = winetest_get_mainargs(&arg_v);
2087
2088         test_smart_tee_filter();
2089         test_CaptureGraphBuilder_RenderStream();
2090         test_AviMux_QueryInterface();
2091         test_AviMux(arg_c>2 ? arg_v[2] : NULL);
2092         test_AviCo();
2093
2094         CoUninitialize();
2095     }
2096     else
2097         skip("CoInitialize failed\n");
2098 }