dlls/qcap/avimux.c

   1 /*
   2  * Copyright (C) 2013 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "qcap_private.h"
  20 #include "vfw.h"
  21 #include "aviriff.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  24
  25 #define MAX_PIN_NO 128
  26 #define AVISUPERINDEX_ENTRIES 2000
  27 #define AVISTDINDEX_ENTRIES 4000
  28 #define ALIGN(x) ((x+1)/2*2)
  29
  30 typedef struct {
  31     struct strmbase_sink pin;
  32     IAMStreamControl IAMStreamControl_iface;
  33     IPropertyBag IPropertyBag_iface;
  34     IQualityControl IQualityControl_iface;
  35
  36     REFERENCE_TIME avg_time_per_frame;
  37     REFERENCE_TIME stop;
  38     int stream_id;
  39     LONGLONG stream_time;
  40
  41     /* strl chunk */
  42     AVISTREAMHEADER strh;
  43     struct {
  44         FOURCC fcc;
  45         DWORD cb;
  46         BYTE data[1];
  47     } *strf;
  48     AVISUPERINDEX *indx;
  49     BYTE indx_data[FIELD_OFFSET(AVISUPERINDEX, aIndex[AVISUPERINDEX_ENTRIES])];
  50
  51     /* movi chunk */
  52     int ix_off;
  53     AVISTDINDEX *ix;
  54     BYTE ix_data[FIELD_OFFSET(AVISTDINDEX, aIndex[AVISTDINDEX_ENTRIES])];
  55
  56     IMediaSample *samples_head;
  57     IMemAllocator *samples_allocator;
  58 } AviMuxIn;
  59
  60 typedef struct {
  61     struct strmbase_filter filter;
  62     IConfigAviMux IConfigAviMux_iface;
  63     IConfigInterleaving IConfigInterleaving_iface;
  64     IMediaSeeking IMediaSeeking_iface;
  65     IPersistMediaPropertyBag IPersistMediaPropertyBag_iface;
  66     ISpecifyPropertyPages ISpecifyPropertyPages_iface;
  67
  68     InterleavingMode mode;
  69     REFERENCE_TIME interleave;
  70     REFERENCE_TIME preroll;
  71
  72     struct strmbase_source source;
  73     IQualityControl IQualityControl_iface;
  74
  75     int input_pin_no;
  76     AviMuxIn *in[MAX_PIN_NO-1];
  77
  78     REFERENCE_TIME start, stop;
  79     AVIMAINHEADER avih;
  80
  81     int idx1_entries;
  82     int idx1_size;
  83     AVIINDEXENTRY *idx1;
  84
  85     int cur_stream;
  86     LONGLONG cur_time;
  87
  88     int buf_pos;
  89     BYTE buf[65536];
  90
  91     int movi_off;
  92     int out_pos;
  93     int size;
  94     IStream *stream;
  95 } AviMux;
  96
  97 static HRESULT create_input_pin(AviMux*);
  98
  99 static inline AviMux* impl_from_strmbase_filter(struct strmbase_filter *filter)
 100 {
 101     return CONTAINING_RECORD(filter, AviMux, filter);
 102 }
 103
 104 static struct strmbase_pin *avi_mux_get_pin(struct strmbase_filter *iface, unsigned int index)
 105 {
 106     AviMux *filter = impl_from_strmbase_filter(iface);
 107
 108     if (!index)
 109         return &filter->source.pin;
 110     else if (index <= filter->input_pin_no)
 111         return &filter->in[index - 1]->pin.pin;
 112     return NULL;
 113 }
 114
 115 static void avi_mux_destroy(struct strmbase_filter *iface)
 116 {
 117     AviMux *filter = impl_from_strmbase_filter(iface);
 118     int i;
 119
 120     strmbase_source_cleanup(&filter->source);
 121
 122     for (i = 0; i < filter->input_pin_no; ++i)
 123     {
 124         IPin_Disconnect(&filter->in[i]->pin.pin.IPin_iface);
 125         IMemAllocator_Release(filter->in[i]->samples_allocator);
 126         filter->in[i]->samples_allocator = NULL;
 127         strmbase_sink_cleanup(&filter->in[i]->pin);
 128         free(filter->in[i]);
 129     }
 130
 131     free(filter->idx1);
 132     strmbase_filter_cleanup(&filter->filter);
 133     free(filter);
 134 }
 135
 136 static HRESULT avi_mux_query_interface(struct strmbase_filter *iface, REFIID iid, void **out)
 137 {
 138     AviMux *filter = impl_from_strmbase_filter(iface);
 139
 140     if (IsEqualGUID(iid, &IID_IConfigAviMux))
 141         *out = &filter->IConfigAviMux_iface;
 142     else if (IsEqualGUID(iid, &IID_IConfigInterleaving))
 143         *out = &filter->IConfigInterleaving_iface;
 144     else if (IsEqualGUID(iid, &IID_IMediaSeeking))
 145         *out = &filter->IMediaSeeking_iface;
 146     else if (IsEqualGUID(iid, &IID_IPersistMediaPropertyBag))
 147         *out = &filter->IPersistMediaPropertyBag_iface;
 148     else if (IsEqualGUID(iid, &IID_ISpecifyPropertyPages))
 149         *out = &filter->ISpecifyPropertyPages_iface;
 150     else
 151         return E_NOINTERFACE;
 152
 153     IUnknown_AddRef((IUnknown *)*out);
 154     return S_OK;
 155 }
 156
 157 static HRESULT out_flush(AviMux *This)
 158 {
 159     ULONG written;
 160     HRESULT hr;
 161
 162     if(!This->buf_pos)
 163         return S_OK;
 164
 165     hr = IStream_Write(This->stream, This->buf, This->buf_pos, &written);
 166     if(FAILED(hr))
 167         return hr;
 168     if (written != This->buf_pos)
 169         return E_FAIL;
 170
 171     This->buf_pos = 0;
 172     return S_OK;
 173 }
 174
 175 static HRESULT out_seek(AviMux *This, int pos)
 176 {
 177     LARGE_INTEGER li;
 178     HRESULT hr;
 179
 180     hr = out_flush(This);
 181     if(FAILED(hr))
 182         return hr;
 183
 184     li.QuadPart = pos;
 185     hr = IStream_Seek(This->stream, li, STREAM_SEEK_SET, NULL);
 186     if(FAILED(hr))
 187         return hr;
 188
 189     This->out_pos = pos;
 190     if(This->out_pos > This->size)
 191         This->size = This->out_pos;
 192     return hr;
 193 }
 194
 195 static HRESULT out_write(AviMux *This, const void *data, int size)
 196 {
 197     int chunk_size;
 198     HRESULT hr;
 199
 200     while(1) {
 201         if (size > sizeof(This->buf) - This->buf_pos)
 202             chunk_size = sizeof(This->buf) - This->buf_pos;
 203         else
 204             chunk_size = size;
 205
 206         memcpy(This->buf + This->buf_pos, data, chunk_size);
 207         size -= chunk_size;
 208         data = (const BYTE*)data + chunk_size;
 209         This->buf_pos += chunk_size;
 210         This->out_pos += chunk_size;
 211         if (This->out_pos > This->size)
 212             This->size = This->out_pos;
 213
 214         if(!size)
 215             break;
 216         hr = out_flush(This);
 217         if(FAILED(hr))
 218             return hr;
 219     }
 220
 221     return S_OK;
 222 }
 223
 224 static inline HRESULT idx1_add_entry(AviMux *avimux, DWORD ckid, DWORD flags, DWORD off, DWORD len)
 225 {
 226     if(avimux->idx1_entries == avimux->idx1_size) {
 227         AVIINDEXENTRY *new_idx = realloc(avimux->idx1, sizeof(*avimux->idx1) * 2 * avimux->idx1_size);
 228         if(!new_idx)
 229             return E_OUTOFMEMORY;
 230
 231         avimux->idx1_size *= 2;
 232         avimux->idx1 = new_idx;
 233     }
 234
 235     avimux->idx1[avimux->idx1_entries].ckid = ckid;
 236     avimux->idx1[avimux->idx1_entries].dwFlags = flags;
 237     avimux->idx1[avimux->idx1_entries].dwChunkOffset = off;
 238     avimux->idx1[avimux->idx1_entries].dwChunkLength = len;
 239     avimux->idx1_entries++;
 240     return S_OK;
 241 }
 242
 243 static HRESULT flush_queue(AviMux *avimux, AviMuxIn *avimuxin, BOOL closing)
 244 {
 245     IMediaSample *sample, **prev, **head_prev;
 246     BYTE *data;
 247     RIFFCHUNK rf;
 248     DWORD size;
 249     DWORD flags;
 250     HRESULT hr;
 251
 252     if (avimux->cur_stream != avimuxin->stream_id)
 253         return S_OK;
 254
 255     while(avimuxin->samples_head) {
 256         hr = IMediaSample_GetPointer(avimuxin->samples_head, (BYTE**)&head_prev);
 257         if(FAILED(hr))
 258             return hr;
 259         head_prev--;
 260
 261         hr = IMediaSample_GetPointer(*head_prev, (BYTE**)&prev);
 262         if(FAILED(hr))
 263             return hr;
 264         prev--;
 265
 266         sample = *head_prev;
 267         size = IMediaSample_GetActualDataLength(sample);
 268         hr = IMediaSample_GetPointer(sample, &data);
 269         if(FAILED(hr))
 270             return hr;
 271         flags = IMediaSample_IsDiscontinuity(sample)==S_OK ? AM_SAMPLE_TIMEDISCONTINUITY : 0;
 272         if(IMediaSample_IsSyncPoint(sample) == S_OK)
 273             flags |= AM_SAMPLE_SPLICEPOINT;
 274
 275         if (avimuxin->stream_time + (closing ? 0 : avimuxin->strh.dwScale) > avimux->cur_time
 276                 && !(flags & AM_SAMPLE_TIMEDISCONTINUITY))
 277         {
 278             if(closing)
 279                 break;
 280
 281             avimux->cur_stream++;
 282             if(avimux->cur_stream >= avimux->input_pin_no-1) {
 283                 avimux->cur_time += avimux->interleave;
 284                 avimux->cur_stream = 0;
 285             }
 286             avimuxin = avimux->in[avimux->cur_stream];
 287             continue;
 288         }
 289
 290         if(avimuxin->ix->nEntriesInUse == AVISTDINDEX_ENTRIES) {
 291             /* TODO: use output pins Deliver/Receive method */
 292             hr = out_seek(avimux, avimuxin->ix_off);
 293             if(FAILED(hr))
 294                 return hr;
 295             hr = out_write(avimux, avimuxin->ix, sizeof(avimuxin->ix_data));
 296             if(FAILED(hr))
 297                 return hr;
 298
 299             avimuxin->indx->aIndex[avimuxin->indx->nEntriesInUse].qwOffset = avimuxin->ix_off;
 300             avimuxin->indx->aIndex[avimuxin->indx->nEntriesInUse].dwSize = sizeof(avimuxin->ix_data);
 301             avimuxin->indx->aIndex[avimuxin->indx->nEntriesInUse].dwDuration = AVISTDINDEX_ENTRIES;
 302             avimuxin->indx->nEntriesInUse++;
 303
 304             memset(avimuxin->ix->aIndex, 0, sizeof(avimuxin->ix->aIndex)*avimuxin->ix->nEntriesInUse);
 305             avimuxin->ix->nEntriesInUse = 0;
 306             avimuxin->ix->qwBaseOffset = 0;
 307
 308             avimuxin->ix_off = avimux->size;
 309             avimux->size += sizeof(avimuxin->ix_data);
 310         }
 311
 312         if(*head_prev == avimuxin->samples_head)
 313             avimuxin->samples_head = NULL;
 314         else
 315             *head_prev = *prev;
 316
 317         avimuxin->stream_time += avimuxin->strh.dwScale;
 318         avimuxin->strh.dwLength++;
 319         if(!(flags & AM_SAMPLE_TIMEDISCONTINUITY)) {
 320             if(!avimuxin->ix->qwBaseOffset)
 321                 avimuxin->ix->qwBaseOffset = avimux->size;
 322             avimuxin->ix->aIndex[avimuxin->ix->nEntriesInUse].dwOffset =
 323                     avimux->size + sizeof(RIFFCHUNK) - avimuxin->ix->qwBaseOffset;
 324
 325             hr = out_seek(avimux, avimux->size);
 326             if(FAILED(hr)) {
 327                 IMediaSample_Release(sample);
 328                 return hr;
 329             }
 330         }
 331         avimuxin->ix->aIndex[avimuxin->ix->nEntriesInUse].dwSize = size |
 332             (flags & AM_SAMPLE_SPLICEPOINT ? 0 : AVISTDINDEX_DELTAFRAME);
 333         avimuxin->ix->nEntriesInUse++;
 334
 335         rf.fcc = FCC('0'+avimuxin->stream_id/10, '0'+avimuxin->stream_id%10,
 336                 'd', flags & AM_SAMPLE_SPLICEPOINT ? 'b' : 'c');
 337         rf.cb = size;
 338         hr = idx1_add_entry(avimux, rf.fcc, flags & AM_SAMPLE_SPLICEPOINT ? AVIIF_KEYFRAME : 0,
 339                 flags & AM_SAMPLE_TIMEDISCONTINUITY ?
 340                 avimux->idx1[avimux->idx1_entries-1].dwChunkOffset : avimux->size, size);
 341         if(FAILED(hr)) {
 342             IMediaSample_Release(sample);
 343             return hr;
 344         }
 345
 346         if(!(flags & AM_SAMPLE_TIMEDISCONTINUITY)) {
 347             hr = out_write(avimux, &rf, sizeof(rf));
 348             if(FAILED(hr)) {
 349                 IMediaSample_Release(sample);
 350                 return hr;
 351             }
 352             hr = out_write(avimux, data, size);
 353             if(FAILED(hr)) {
 354                 IMediaSample_Release(sample);
 355                 return hr;
 356             }
 357             flags = 0;
 358             hr = out_write(avimux, &flags, ALIGN(rf.cb)-rf.cb);
 359             if(FAILED(hr)) {
 360                 IMediaSample_Release(sample);
 361                 return hr;
 362             }
 363         }
 364         IMediaSample_Release(sample);
 365     }
 366     return S_OK;
 367 }
 368
 369 static HRESULT queue_sample(AviMux *avimux, AviMuxIn *avimuxin, IMediaSample *sample)
 370 {
 371     IMediaSample **prev, **head_prev;
 372     HRESULT hr;
 373
 374     hr = IMediaSample_GetPointer(sample, (BYTE**)&prev);
 375     if(FAILED(hr))
 376         return hr;
 377     prev--;
 378
 379     if(avimuxin->samples_head) {
 380         hr = IMediaSample_GetPointer(avimuxin->samples_head, (BYTE**)&head_prev);
 381         if(FAILED(hr))
 382             return hr;
 383         head_prev--;
 384
 385         *prev = *head_prev;
 386         *head_prev = sample;
 387     }else {
 388         *prev = sample;
 389     }
 390     avimuxin->samples_head = sample;
 391     IMediaSample_AddRef(sample);
 392
 393     return flush_queue(avimux, avimuxin, FALSE);
 394 }
 395
 396 static HRESULT avi_mux_cleanup_stream(struct strmbase_filter *iface)
 397 {
 398     AviMux *This = impl_from_strmbase_filter(iface);
 399     HRESULT hr;
 400     int i;
 401
 402     if (This->stream)
 403     {
 404         AVIEXTHEADER dmlh;
 405         RIFFCHUNK rc;
 406         RIFFLIST rl;
 407         int idx1_off, empty_stream;
 408
 409         empty_stream = This->cur_stream;
 410         for(i=empty_stream+1; ; i++) {
 411             if(i >= This->input_pin_no-1)
 412                 i = 0;
 413             if(i == empty_stream)
 414                 break;
 415
 416             This->cur_stream = i;
 417             hr = flush_queue(This, This->in[This->cur_stream], TRUE);
 418             if(FAILED(hr))
 419                 return hr;
 420         }
 421
 422         idx1_off = This->size;
 423         rc.fcc = ckidAVIOLDINDEX;
 424         rc.cb = This->idx1_entries * sizeof(*This->idx1);
 425         hr = out_write(This, &rc, sizeof(rc));
 426         if(FAILED(hr))
 427             return hr;
 428         hr = out_write(This, This->idx1, This->idx1_entries * sizeof(*This->idx1));
 429         if(FAILED(hr))
 430             return hr;
 431         /* native writes 8 '\0' characters after the end of RIFF data */
 432         i = 0;
 433         hr = out_write(This, &i, sizeof(i));
 434         if(FAILED(hr))
 435             return hr;
 436         hr = out_write(This, &i, sizeof(i));
 437         if(FAILED(hr))
 438             return hr;
 439
 440         for(i=0; i<This->input_pin_no; i++) {
 441             if(!This->in[i]->pin.pin.peer)
 442                 continue;
 443
 444             hr = out_seek(This, This->in[i]->ix_off);
 445             if(FAILED(hr))
 446                 return hr;
 447
 448             This->in[i]->indx->aIndex[This->in[i]->indx->nEntriesInUse].qwOffset = This->in[i]->ix_off;
 449             This->in[i]->indx->aIndex[This->in[i]->indx->nEntriesInUse].dwSize = sizeof(This->in[i]->ix_data);
 450             This->in[i]->indx->aIndex[This->in[i]->indx->nEntriesInUse].dwDuration = This->in[i]->strh.dwLength;
 451             if(This->in[i]->indx->nEntriesInUse) {
 452                 This->in[i]->indx->aIndex[This->in[i]->indx->nEntriesInUse].dwDuration -=
 453                     This->in[i]->indx->aIndex[This->in[i]->indx->nEntriesInUse-1].dwDuration;
 454             }
 455             This->in[i]->indx->nEntriesInUse++;
 456             hr = out_write(This, This->in[i]->ix, sizeof(This->in[i]->ix_data));
 457             if(FAILED(hr))
 458                 return hr;
 459         }
 460
 461         hr = out_seek(This, 0);
 462         if(FAILED(hr))
 463             return hr;
 464
 465         rl.fcc = FCC('R','I','F','F');
 466         rl.cb = This->size - sizeof(RIFFCHUNK) - 2 * sizeof(int);
 467         rl.fccListType = FCC('A','V','I',' ');
 468         hr = out_write(This, &rl, sizeof(rl));
 469         if(FAILED(hr))
 470             return hr;
 471
 472         rl.fcc = FCC('L','I','S','T');
 473         rl.cb = This->movi_off - sizeof(RIFFLIST) - sizeof(RIFFCHUNK);
 474         rl.fccListType = FCC('h','d','r','l');
 475         hr = out_write(This, &rl, sizeof(rl));
 476         if(FAILED(hr))
 477             return hr;
 478
 479         /* FIXME: set This->avih.dwMaxBytesPerSec value */
 480         This->avih.dwTotalFrames = (This->stop-This->start) / 10 / This->avih.dwMicroSecPerFrame;
 481         hr = out_write(This, &This->avih, sizeof(This->avih));
 482         if(FAILED(hr))
 483             return hr;
 484
 485         for(i=0; i<This->input_pin_no; i++) {
 486             if(!This->in[i]->pin.pin.peer)
 487                 continue;
 488
 489             rl.cb = sizeof(FOURCC) + sizeof(AVISTREAMHEADER) + sizeof(RIFFCHUNK) +
 490                 This->in[i]->strf->cb + sizeof(This->in[i]->indx_data);
 491             rl.fccListType = ckidSTREAMLIST;
 492             hr = out_write(This, &rl, sizeof(rl));
 493             if(FAILED(hr))
 494                 return hr;
 495
 496             hr = out_write(This, &This->in[i]->strh, sizeof(AVISTREAMHEADER));
 497             if(FAILED(hr))
 498                 return hr;
 499
 500             hr = out_write(This, This->in[i]->strf, sizeof(RIFFCHUNK) + This->in[i]->strf->cb);
 501             if(FAILED(hr))
 502                 return hr;
 503
 504             hr = out_write(This, This->in[i]->indx, sizeof(This->in[i]->indx_data));
 505             if(FAILED(hr))
 506                 return hr;
 507         }
 508
 509         rl.cb = sizeof(dmlh) + sizeof(FOURCC);
 510         rl.fccListType = ckidODML;
 511         hr = out_write(This, &rl, sizeof(rl));
 512         if(FAILED(hr))
 513             return hr;
 514
 515         memset(&dmlh, 0, sizeof(dmlh));
 516         dmlh.fcc = ckidAVIEXTHEADER;
 517         dmlh.cb = sizeof(dmlh) - sizeof(RIFFCHUNK);
 518         dmlh.dwGrandFrames = This->in[0]->strh.dwLength;
 519         hr = out_write(This, &dmlh, sizeof(dmlh));
 520
 521         rl.cb = idx1_off - This->movi_off - sizeof(RIFFCHUNK);
 522         rl.fccListType = FCC('m','o','v','i');
 523         out_write(This, &rl, sizeof(rl));
 524         out_flush(This);
 525
 526         IStream_Release(This->stream);
 527         This->stream = NULL;
 528     }
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT avi_mux_init_stream(struct strmbase_filter *iface)
 534 {
 535     AviMux *This = impl_from_strmbase_filter(iface);
 536     HRESULT hr;
 537     int i, stream_id;
 538
 539     if(This->mode != INTERLEAVE_FULL) {
 540         FIXME("mode not supported (%d)\n", This->mode);
 541         return E_NOTIMPL;
 542     }
 543
 544     for(i=0; i<This->input_pin_no; i++) {
 545         IMediaSeeking *ms;
 546         LONGLONG cur, stop;
 547
 548         if(!This->in[i]->pin.pin.peer)
 549             continue;
 550
 551         hr = IPin_QueryInterface(This->in[i]->pin.pin.peer,
 552                 &IID_IMediaSeeking, (void**)&ms);
 553         if(FAILED(hr))
 554             continue;
 555
 556         hr = IMediaSeeking_GetPositions(ms, &cur, &stop);
 557         if(FAILED(hr)) {
 558             IMediaSeeking_Release(ms);
 559             continue;
 560         }
 561
 562         FIXME("Use IMediaSeeking to fill stream header\n");
 563         IMediaSeeking_Release(ms);
 564     }
 565
 566     if (This->source.pMemInputPin)
 567     {
 568         hr = IMemInputPin_QueryInterface(This->source.pMemInputPin,
 569                 &IID_IStream, (void **)&This->stream);
 570         if(FAILED(hr))
 571             return hr;
 572     }
 573
 574     This->idx1_entries = 0;
 575     if(!This->idx1_size) {
 576         This->idx1_size = 1024;
 577         if (!(This->idx1 = malloc(sizeof(*This->idx1) * This->idx1_size)))
 578             return E_OUTOFMEMORY;
 579     }
 580
 581     This->size = 3*sizeof(RIFFLIST) + sizeof(AVIMAINHEADER) + sizeof(AVIEXTHEADER);
 582     This->start = -1;
 583     This->stop = -1;
 584     memset(&This->avih, 0, sizeof(This->avih));
 585     for(i=0; i<This->input_pin_no; i++) {
 586         if(!This->in[i]->pin.pin.peer)
 587             continue;
 588
 589         This->avih.dwStreams++;
 590         This->size += sizeof(RIFFLIST) + sizeof(AVISTREAMHEADER) + sizeof(RIFFCHUNK)
 591                 + This->in[i]->strf->cb + sizeof(This->in[i]->indx_data);
 592
 593         This->in[i]->strh.dwScale = MulDiv(This->in[i]->avg_time_per_frame, This->interleave, 10000000);
 594         This->in[i]->strh.dwRate = This->interleave;
 595
 596         hr = IMemAllocator_Commit(This->in[i]->pin.pAllocator);
 597         if(FAILED(hr)) {
 598             if (This->stream)
 599             {
 600                 IStream_Release(This->stream);
 601                 This->stream = NULL;
 602             }
 603             return hr;
 604         }
 605     }
 606
 607     This->movi_off = This->size;
 608     This->size += sizeof(RIFFLIST);
 609
 610     idx1_add_entry(This, FCC('7','F','x','x'), 0, This->movi_off + sizeof(RIFFLIST), 0);
 611
 612     stream_id = 0;
 613     for(i=0; i<This->input_pin_no; i++) {
 614         if(!This->in[i]->pin.pin.peer)
 615             continue;
 616
 617         This->in[i]->ix_off = This->size;
 618         This->size += sizeof(This->in[i]->ix_data);
 619         This->in[i]->ix->fcc = FCC('i','x','0'+stream_id/10,'0'+stream_id%10);
 620         This->in[i]->ix->cb = sizeof(This->in[i]->ix_data) - sizeof(RIFFCHUNK);
 621         This->in[i]->ix->wLongsPerEntry = 2;
 622         This->in[i]->ix->bIndexSubType = 0;
 623         This->in[i]->ix->bIndexType = AVI_INDEX_OF_CHUNKS;
 624         This->in[i]->ix->dwChunkId = FCC('0'+stream_id/10,'0'+stream_id%10,'d','b');
 625         This->in[i]->ix->qwBaseOffset = 0;
 626
 627         This->in[i]->indx->fcc = ckidAVISUPERINDEX;
 628         This->in[i]->indx->cb = sizeof(This->in[i]->indx_data) - sizeof(RIFFCHUNK);
 629         This->in[i]->indx->wLongsPerEntry = 4;
 630         This->in[i]->indx->bIndexSubType = 0;
 631         This->in[i]->indx->bIndexType = AVI_INDEX_OF_INDEXES;
 632         This->in[i]->indx->dwChunkId = This->in[i]->ix->dwChunkId;
 633         This->in[i]->stream_id = stream_id++;
 634     }
 635
 636     This->buf_pos = 0;
 637     This->out_pos = 0;
 638
 639     This->avih.fcc = ckidMAINAVIHEADER;
 640     This->avih.cb = sizeof(AVIMAINHEADER) - sizeof(RIFFCHUNK);
 641     /* TODO: Use first video stream */
 642     This->avih.dwMicroSecPerFrame = This->in[0]->avg_time_per_frame/10;
 643     This->avih.dwPaddingGranularity = 1;
 644     This->avih.dwFlags = AVIF_TRUSTCKTYPE | AVIF_HASINDEX;
 645     This->avih.dwWidth = ((BITMAPINFOHEADER*)This->in[0]->strf->data)->biWidth;
 646     This->avih.dwHeight = ((BITMAPINFOHEADER*)This->in[0]->strf->data)->biHeight;
 647
 648     return S_OK;
 649 }
 650
 651 static const struct strmbase_filter_ops filter_ops =
 652 {
 653     .filter_get_pin = avi_mux_get_pin,
 654     .filter_destroy = avi_mux_destroy,
 655     .filter_query_interface = avi_mux_query_interface,
 656     .filter_init_stream = avi_mux_init_stream,
 657     .filter_cleanup_stream = avi_mux_cleanup_stream,
 658 };
 659
 660 static inline AviMux* impl_from_IConfigAviMux(IConfigAviMux *iface)
 661 {
 662     return CONTAINING_RECORD(iface, AviMux, IConfigAviMux_iface);
 663 }
 664
 665 static HRESULT WINAPI ConfigAviMux_QueryInterface(
 666         IConfigAviMux *iface, REFIID riid, void **ppv)
 667 {
 668     AviMux *This = impl_from_IConfigAviMux(iface);
 669     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
 670 }
 671
 672 static ULONG WINAPI ConfigAviMux_AddRef(IConfigAviMux *iface)
 673 {
 674     AviMux *This = impl_from_IConfigAviMux(iface);
 675     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 676 }
 677
 678 static ULONG WINAPI ConfigAviMux_Release(IConfigAviMux *iface)
 679 {
 680     AviMux *This = impl_from_IConfigAviMux(iface);
 681     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 682 }
 683
 684 static HRESULT WINAPI ConfigAviMux_SetMasterStream(IConfigAviMux *iface, LONG iStream)
 685 {
 686     AviMux *This = impl_from_IConfigAviMux(iface);
 687     FIXME("filter %p, index %ld, stub!\n", This, iStream);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI ConfigAviMux_GetMasterStream(IConfigAviMux *iface, LONG *pStream)
 692 {
 693     AviMux *This = impl_from_IConfigAviMux(iface);
 694     FIXME("(%p)->(%p)\n", This, pStream);
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI ConfigAviMux_SetOutputCompatibilityIndex(
 699         IConfigAviMux *iface, BOOL fOldIndex)
 700 {
 701     AviMux *This = impl_from_IConfigAviMux(iface);
 702     FIXME("(%p)->(%x)\n", This, fOldIndex);
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI ConfigAviMux_GetOutputCompatibilityIndex(
 707         IConfigAviMux *iface, BOOL *pfOldIndex)
 708 {
 709     AviMux *This = impl_from_IConfigAviMux(iface);
 710     FIXME("(%p)->(%p)\n", This, pfOldIndex);
 711     return E_NOTIMPL;
 712 }
 713
 714 static const IConfigAviMuxVtbl ConfigAviMuxVtbl = {
 715     ConfigAviMux_QueryInterface,
 716     ConfigAviMux_AddRef,
 717     ConfigAviMux_Release,
 718     ConfigAviMux_SetMasterStream,
 719     ConfigAviMux_GetMasterStream,
 720     ConfigAviMux_SetOutputCompatibilityIndex,
 721     ConfigAviMux_GetOutputCompatibilityIndex
 722 };
 723
 724 static inline AviMux* impl_from_IConfigInterleaving(IConfigInterleaving *iface)
 725 {
 726     return CONTAINING_RECORD(iface, AviMux, IConfigInterleaving_iface);
 727 }
 728
 729 static HRESULT WINAPI ConfigInterleaving_QueryInterface(
 730         IConfigInterleaving *iface, REFIID riid, void **ppv)
 731 {
 732     AviMux *This = impl_from_IConfigInterleaving(iface);
 733     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
 734 }
 735
 736 static ULONG WINAPI ConfigInterleaving_AddRef(IConfigInterleaving *iface)
 737 {
 738     AviMux *This = impl_from_IConfigInterleaving(iface);
 739     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 740 }
 741
 742 static ULONG WINAPI ConfigInterleaving_Release(IConfigInterleaving *iface)
 743 {
 744     AviMux *This = impl_from_IConfigInterleaving(iface);
 745     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 746 }
 747
 748 static HRESULT WINAPI ConfigInterleaving_put_Mode(
 749         IConfigInterleaving *iface, InterleavingMode mode)
 750 {
 751     AviMux *This = impl_from_IConfigInterleaving(iface);
 752
 753     TRACE("(%p)->(%d)\n", This, mode);
 754
 755     if(mode>INTERLEAVE_NONE_BUFFERED)
 756         return E_INVALIDARG;
 757
 758     if(This->mode != mode) {
 759         if(This->source.pin.peer) {
 760             HRESULT hr = IFilterGraph_Reconnect(This->filter.graph, &This->source.pin.IPin_iface);
 761             if(FAILED(hr))
 762                 return hr;
 763         }
 764
 765         This->mode = mode;
 766     }
 767
 768     return S_OK;
 769 }
 770
 771 static HRESULT WINAPI ConfigInterleaving_get_Mode(
 772         IConfigInterleaving *iface, InterleavingMode *pMode)
 773 {
 774     AviMux *This = impl_from_IConfigInterleaving(iface);
 775     FIXME("(%p)->(%p)\n", This, pMode);
 776     return E_NOTIMPL;
 777 }
 778
 779 static HRESULT WINAPI ConfigInterleaving_put_Interleaving(IConfigInterleaving *iface,
 780         const REFERENCE_TIME *prtInterleave, const REFERENCE_TIME *prtPreroll)
 781 {
 782     AviMux *This = impl_from_IConfigInterleaving(iface);
 783
 784     TRACE("(%p)->(%p %p)\n", This, prtInterleave, prtPreroll);
 785
 786     if(prtInterleave)
 787         This->interleave = *prtInterleave;
 788     if(prtPreroll)
 789         This->preroll = *prtPreroll;
 790     return S_OK;
 791 }
 792
 793 static HRESULT WINAPI ConfigInterleaving_get_Interleaving(IConfigInterleaving *iface,
 794         REFERENCE_TIME *prtInterleave, REFERENCE_TIME *prtPreroll)
 795 {
 796     AviMux *This = impl_from_IConfigInterleaving(iface);
 797     FIXME("(%p)->(%p %p)\n", This, prtInterleave, prtPreroll);
 798     return E_NOTIMPL;
 799 }
 800
 801 static const IConfigInterleavingVtbl ConfigInterleavingVtbl = {
 802     ConfigInterleaving_QueryInterface,
 803     ConfigInterleaving_AddRef,
 804     ConfigInterleaving_Release,
 805     ConfigInterleaving_put_Mode,
 806     ConfigInterleaving_get_Mode,
 807     ConfigInterleaving_put_Interleaving,
 808     ConfigInterleaving_get_Interleaving
 809 };
 810
 811 static inline AviMux* impl_from_IMediaSeeking(IMediaSeeking *iface)
 812 {
 813     return CONTAINING_RECORD(iface, AviMux, IMediaSeeking_iface);
 814 }
 815
 816 static HRESULT WINAPI MediaSeeking_QueryInterface(
 817         IMediaSeeking *iface, REFIID riid, void **ppv)
 818 {
 819     AviMux *This = impl_from_IMediaSeeking(iface);
 820     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
 821 }
 822
 823 static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
 824 {
 825     AviMux *This = impl_from_IMediaSeeking(iface);
 826     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 827 }
 828
 829 static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
 830 {
 831     AviMux *This = impl_from_IMediaSeeking(iface);
 832     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 833 }
 834
 835 static HRESULT WINAPI MediaSeeking_GetCapabilities(
 836         IMediaSeeking *iface, DWORD *pCapabilities)
 837 {
 838     AviMux *This = impl_from_IMediaSeeking(iface);
 839     FIXME("(%p)->(%p)\n", This, pCapabilities);
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI MediaSeeking_CheckCapabilities(
 844         IMediaSeeking *iface, DWORD *pCapabilities)
 845 {
 846     AviMux *This = impl_from_IMediaSeeking(iface);
 847     FIXME("(%p)->(%p)\n", This, pCapabilities);
 848     return E_NOTIMPL;
 849 }
 850
 851 static HRESULT WINAPI MediaSeeking_IsFormatSupported(
 852         IMediaSeeking *iface, const GUID *pFormat)
 853 {
 854     AviMux *This = impl_from_IMediaSeeking(iface);
 855     FIXME("(%p)->(%s)\n", This, debugstr_guid(pFormat));
 856     return E_NOTIMPL;
 857 }
 858
 859 static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(
 860         IMediaSeeking *iface, GUID *pFormat)
 861 {
 862     AviMux *This = impl_from_IMediaSeeking(iface);
 863     FIXME("(%p)->(%p)\n", This, pFormat);
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI MediaSeeking_GetTimeFormat(
 868         IMediaSeeking *iface, GUID *pFormat)
 869 {
 870     AviMux *This = impl_from_IMediaSeeking(iface);
 871     FIXME("(%p)->(%p)\n", This, pFormat);
 872     return E_NOTIMPL;
 873 }
 874
 875 static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(
 876         IMediaSeeking *iface, const GUID *pFormat)
 877 {
 878     AviMux *This = impl_from_IMediaSeeking(iface);
 879     FIXME("(%p)->(%s)\n", This, debugstr_guid(pFormat));
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI MediaSeeking_SetTimeFormat(
 884         IMediaSeeking *iface, const GUID *pFormat)
 885 {
 886     AviMux *This = impl_from_IMediaSeeking(iface);
 887     FIXME("(%p)->(%s)\n", This, debugstr_guid(pFormat));
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI MediaSeeking_GetDuration(
 892         IMediaSeeking *iface, LONGLONG *pDuration)
 893 {
 894     AviMux *This = impl_from_IMediaSeeking(iface);
 895     FIXME("(%p)->(%p)\n", This, pDuration);
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI MediaSeeking_GetStopPosition(
 900         IMediaSeeking *iface, LONGLONG *pStop)
 901 {
 902     AviMux *This = impl_from_IMediaSeeking(iface);
 903     FIXME("(%p)->(%p)\n", This, pStop);
 904     return E_NOTIMPL;
 905 }
 906
 907 static HRESULT WINAPI MediaSeeking_GetCurrentPosition(
 908         IMediaSeeking *iface, LONGLONG *pCurrent)
 909 {
 910     AviMux *This = impl_from_IMediaSeeking(iface);
 911     FIXME("(%p)->(%p)\n", This, pCurrent);
 912     return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget,
 916         const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
 917 {
 918     AviMux *This = impl_from_IMediaSeeking(iface);
 919     FIXME("(%p)->(%p %s %s %s)\n", This, pTarget, debugstr_guid(pTargetFormat),
 920             wine_dbgstr_longlong(Source), debugstr_guid(pSourceFormat));
 921     return E_NOTIMPL;
 922 }
 923
 924 static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *pCurrent,
 925         DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags)
 926 {
 927     AviMux *This = impl_from_IMediaSeeking(iface);
 928     FIXME("(%p)->(%p %#lx %p %#lx)\n", This, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
 929     return E_NOTIMPL;
 930 }
 931
 932 static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface,
 933         LONGLONG *pCurrent, LONGLONG *pStop)
 934 {
 935     AviMux *This = impl_from_IMediaSeeking(iface);
 936     FIXME("(%p)->(%p %p)\n", This, pCurrent, pStop);
 937     return E_NOTIMPL;
 938 }
 939
 940 static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface,
 941         LONGLONG *pEarliest, LONGLONG *pLatest)
 942 {
 943     AviMux *This = impl_from_IMediaSeeking(iface);
 944     FIXME("(%p)->(%p %p)\n", This, pEarliest, pLatest);
 945     return E_NOTIMPL;
 946 }
 947
 948 static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
 949 {
 950     AviMux *This = impl_from_IMediaSeeking(iface);
 951     FIXME("(%p)->(%lf)\n", This, dRate);
 952     return E_NOTIMPL;
 953 }
 954
 955 static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
 956 {
 957     AviMux *This = impl_from_IMediaSeeking(iface);
 958     FIXME("(%p)->(%p)\n", This, pdRate);
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
 963 {
 964     AviMux *This = impl_from_IMediaSeeking(iface);
 965     FIXME("(%p)->(%p)\n", This, pllPreroll);
 966     return E_NOTIMPL;
 967 }
 968
 969 static const IMediaSeekingVtbl MediaSeekingVtbl = {
 970     MediaSeeking_QueryInterface,
 971     MediaSeeking_AddRef,
 972     MediaSeeking_Release,
 973     MediaSeeking_GetCapabilities,
 974     MediaSeeking_CheckCapabilities,
 975     MediaSeeking_IsFormatSupported,
 976     MediaSeeking_QueryPreferredFormat,
 977     MediaSeeking_GetTimeFormat,
 978     MediaSeeking_IsUsingTimeFormat,
 979     MediaSeeking_SetTimeFormat,
 980     MediaSeeking_GetDuration,
 981     MediaSeeking_GetStopPosition,
 982     MediaSeeking_GetCurrentPosition,
 983     MediaSeeking_ConvertTimeFormat,
 984     MediaSeeking_SetPositions,
 985     MediaSeeking_GetPositions,
 986     MediaSeeking_GetAvailable,
 987     MediaSeeking_SetRate,
 988     MediaSeeking_GetRate,
 989     MediaSeeking_GetPreroll
 990 };
 991
 992 static inline AviMux* impl_from_IPersistMediaPropertyBag(IPersistMediaPropertyBag *iface)
 993 {
 994     return CONTAINING_RECORD(iface, AviMux, IPersistMediaPropertyBag_iface);
 995 }
 996
 997 static HRESULT WINAPI PersistMediaPropertyBag_QueryInterface(
 998         IPersistMediaPropertyBag *iface, REFIID riid, void **ppv)
 999 {
1000     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1001     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
1002 }
1003
1004 static ULONG WINAPI PersistMediaPropertyBag_AddRef(IPersistMediaPropertyBag *iface)
1005 {
1006     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1007     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1008 }
1009
1010 static ULONG WINAPI PersistMediaPropertyBag_Release(IPersistMediaPropertyBag *iface)
1011 {
1012     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1013     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1014 }
1015
1016 static HRESULT WINAPI PersistMediaPropertyBag_GetClassID(
1017         IPersistMediaPropertyBag *iface, CLSID *pClassID)
1018 {
1019     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1020     return IBaseFilter_GetClassID(&This->filter.IBaseFilter_iface, pClassID);
1021 }
1022
1023 static HRESULT WINAPI PersistMediaPropertyBag_InitNew(IPersistMediaPropertyBag *iface)
1024 {
1025     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1026     FIXME("(%p)->()\n", This);
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI PersistMediaPropertyBag_Load(IPersistMediaPropertyBag *iface,
1031         IMediaPropertyBag *pPropBag, IErrorLog *pErrorLog)
1032 {
1033     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1034     FIXME("(%p)->()\n", This);
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI PersistMediaPropertyBag_Save(IPersistMediaPropertyBag *iface,
1039         IMediaPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
1040 {
1041     AviMux *This = impl_from_IPersistMediaPropertyBag(iface);
1042     FIXME("(%p)->()\n", This);
1043     return E_NOTIMPL;
1044 }
1045
1046 static const IPersistMediaPropertyBagVtbl PersistMediaPropertyBagVtbl = {
1047     PersistMediaPropertyBag_QueryInterface,
1048     PersistMediaPropertyBag_AddRef,
1049     PersistMediaPropertyBag_Release,
1050     PersistMediaPropertyBag_GetClassID,
1051     PersistMediaPropertyBag_InitNew,
1052     PersistMediaPropertyBag_Load,
1053     PersistMediaPropertyBag_Save
1054 };
1055
1056 static inline AviMux* impl_from_ISpecifyPropertyPages(ISpecifyPropertyPages *iface)
1057 {
1058     return CONTAINING_RECORD(iface, AviMux, ISpecifyPropertyPages_iface);
1059 }
1060
1061 static HRESULT WINAPI SpecifyPropertyPages_QueryInterface(
1062         ISpecifyPropertyPages *iface, REFIID riid, void **ppv)
1063 {
1064     AviMux *This = impl_from_ISpecifyPropertyPages(iface);
1065     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
1066 }
1067
1068 static ULONG WINAPI SpecifyPropertyPages_AddRef(ISpecifyPropertyPages *iface)
1069 {
1070     AviMux *This = impl_from_ISpecifyPropertyPages(iface);
1071     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1072 }
1073
1074 static ULONG WINAPI SpecifyPropertyPages_Release(ISpecifyPropertyPages *iface)
1075 {
1076     AviMux *This = impl_from_ISpecifyPropertyPages(iface);
1077     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1078 }
1079
1080 static HRESULT WINAPI SpecifyPropertyPages_GetPages(
1081         ISpecifyPropertyPages *iface, CAUUID *pPages)
1082 {
1083     AviMux *This = impl_from_ISpecifyPropertyPages(iface);
1084     FIXME("(%p)->(%p)\n", This, pPages);
1085     return E_NOTIMPL;
1086 }
1087
1088 static const ISpecifyPropertyPagesVtbl SpecifyPropertyPagesVtbl = {
1089     SpecifyPropertyPages_QueryInterface,
1090     SpecifyPropertyPages_AddRef,
1091     SpecifyPropertyPages_Release,
1092     SpecifyPropertyPages_GetPages
1093 };
1094
1095 static inline AviMux *impl_from_source_pin(struct strmbase_pin *iface)
1096 {
1097     return CONTAINING_RECORD(iface, AviMux, source.pin);
1098 }
1099
1100 static HRESULT source_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
1101 {
1102     AviMux *filter = impl_from_source_pin(iface);
1103
1104     if (IsEqualGUID(iid, &IID_IQualityControl))
1105         *out = &filter->IQualityControl_iface;
1106     else
1107         return E_NOINTERFACE;
1108
1109     IUnknown_AddRef((IUnknown *)*out);
1110     return S_OK;
1111 }
1112
1113 static HRESULT source_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
1114 {
1115     if (!IsEqualGUID(&mt->majortype, &GUID_NULL) && !IsEqualGUID(&mt->majortype, &MEDIATYPE_Stream))
1116         return S_FALSE;
1117     if (!IsEqualGUID(&mt->subtype, &GUID_NULL) && !IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_Avi))
1118         return S_FALSE;
1119     return S_OK;
1120 }
1121
1122 static HRESULT WINAPI AviMuxOut_AttemptConnection(struct strmbase_source *iface,
1123         IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
1124 {
1125     AviMux *filter = impl_from_source_pin(&iface->pin);
1126     PIN_DIRECTION dir;
1127     unsigned int i;
1128     HRESULT hr;
1129
1130     hr = IPin_QueryDirection(pReceivePin, &dir);
1131     if(hr==S_OK && dir!=PINDIR_INPUT)
1132         return VFW_E_INVALID_DIRECTION;
1133
1134     if (FAILED(hr = BaseOutputPinImpl_AttemptConnection(iface, pReceivePin, pmt)))
1135         return hr;
1136
1137     for (i = 0; i < filter->input_pin_no; ++i)
1138     {
1139         if (!filter->in[i]->pin.pin.peer)
1140             continue;
1141
1142         hr = IFilterGraph_Reconnect(filter->filter.graph, &filter->in[i]->pin.pin.IPin_iface);
1143         if (FAILED(hr))
1144         {
1145             IPin_Disconnect(&iface->pin.IPin_iface);
1146             break;
1147         }
1148     }
1149
1150     return hr;
1151 }
1152
1153 static HRESULT source_get_media_type(struct strmbase_pin *base, unsigned int iPosition, AM_MEDIA_TYPE *amt)
1154 {
1155     TRACE("(%p)->(%d %p)\n", base, iPosition, amt);
1156
1157     if(iPosition > 0)
1158         return VFW_S_NO_MORE_ITEMS;
1159
1160     amt->majortype = MEDIATYPE_Stream;
1161     amt->subtype = MEDIASUBTYPE_Avi;
1162     amt->bFixedSizeSamples = TRUE;
1163     amt->bTemporalCompression = FALSE;
1164     amt->lSampleSize = 1;
1165     amt->formattype = GUID_NULL;
1166     amt->pUnk = NULL;
1167     amt->cbFormat = 0;
1168     amt->pbFormat = NULL;
1169     return S_OK;
1170 }
1171
1172 static HRESULT WINAPI AviMuxOut_DecideAllocator(struct strmbase_source *base,
1173         IMemInputPin *pPin, IMemAllocator **pAlloc)
1174 {
1175     ALLOCATOR_PROPERTIES req, actual;
1176     HRESULT hr;
1177
1178     TRACE("(%p)->(%p %p)\n", base, pPin, pAlloc);
1179
1180     if (FAILED(hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL,
1181             CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (void **)pAlloc)))
1182     {
1183         ERR("Failed to create allocator, hr %#lx.\n", hr);
1184         return hr;
1185     }
1186
1187     hr = IMemInputPin_GetAllocatorRequirements(pPin, &req);
1188     if(FAILED(hr))
1189         req.cbAlign = 1;
1190     req.cBuffers = 32;
1191     req.cbBuffer = 0;
1192     req.cbPrefix = 0;
1193
1194     hr = IMemAllocator_SetProperties(*pAlloc, &req, &actual);
1195     if(FAILED(hr))
1196         return hr;
1197
1198     return IMemInputPin_NotifyAllocator(pPin, *pAlloc, TRUE);
1199 }
1200
1201 static const struct strmbase_source_ops source_ops =
1202 {
1203     .base.pin_query_interface = source_query_interface,
1204     .base.pin_query_accept = source_query_accept,
1205     .base.pin_get_media_type = source_get_media_type,
1206     .pfnAttemptConnection = AviMuxOut_AttemptConnection,
1207     .pfnDecideAllocator = AviMuxOut_DecideAllocator,
1208 };
1209
1210 static inline AviMux* impl_from_out_IQualityControl(IQualityControl *iface)
1211 {
1212     return CONTAINING_RECORD(iface, AviMux, IQualityControl_iface);
1213 }
1214
1215 static HRESULT WINAPI AviMuxOut_QualityControl_QueryInterface(
1216         IQualityControl *iface, REFIID riid, void **ppv)
1217 {
1218     AviMux *This = impl_from_out_IQualityControl(iface);
1219     return IPin_QueryInterface(&This->source.pin.IPin_iface, riid, ppv);
1220 }
1221
1222 static ULONG WINAPI AviMuxOut_QualityControl_AddRef(IQualityControl *iface)
1223 {
1224     AviMux *This = impl_from_out_IQualityControl(iface);
1225     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1226 }
1227
1228 static ULONG WINAPI AviMuxOut_QualityControl_Release(IQualityControl *iface)
1229 {
1230     AviMux *This = impl_from_out_IQualityControl(iface);
1231     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1232 }
1233
1234 static HRESULT WINAPI AviMuxOut_QualityControl_Notify(IQualityControl *iface,
1235         IBaseFilter *sender, Quality q)
1236 {
1237     AviMux *filter = impl_from_out_IQualityControl(iface);
1238
1239     FIXME("filter %p, sender %p, type %#x, proportion %ld, late %s, timestamp %s, stub!\n",
1240             filter, sender, q.Type, q.Proportion,
1241             wine_dbgstr_longlong(q.Late), wine_dbgstr_longlong(q.TimeStamp));
1242
1243     return E_NOTIMPL;
1244 }
1245
1246 static HRESULT WINAPI AviMuxOut_QualityControl_SetSink(
1247         IQualityControl *iface, IQualityControl *piqc)
1248 {
1249     AviMux *This = impl_from_out_IQualityControl(iface);
1250     FIXME("(%p)->(%p)\n", This, piqc);
1251     return E_NOTIMPL;
1252 }
1253
1254 static const IQualityControlVtbl AviMuxOut_QualityControlVtbl = {
1255     AviMuxOut_QualityControl_QueryInterface,
1256     AviMuxOut_QualityControl_AddRef,
1257     AviMuxOut_QualityControl_Release,
1258     AviMuxOut_QualityControl_Notify,
1259     AviMuxOut_QualityControl_SetSink
1260 };
1261
1262 static inline AviMuxIn *impl_sink_from_strmbase_pin(struct strmbase_pin *iface)
1263 {
1264     return CONTAINING_RECORD(iface, AviMuxIn, pin.pin);
1265 }
1266
1267 static HRESULT sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
1268 {
1269     AviMuxIn *pin = impl_sink_from_strmbase_pin(iface);
1270
1271     if (IsEqualGUID(iid, &IID_IAMStreamControl))
1272         *out = &pin->IAMStreamControl_iface;
1273     else if (IsEqualGUID(iid, &IID_IMemInputPin))
1274         *out = &pin->pin.IMemInputPin_iface;
1275     else if (IsEqualGUID(iid, &IID_IPropertyBag))
1276         *out = &pin->IPropertyBag_iface;
1277     else if (IsEqualGUID(iid, &IID_IQualityControl))
1278         *out = &pin->IQualityControl_iface;
1279     else
1280         return E_NOINTERFACE;
1281
1282     IUnknown_AddRef((IUnknown *)*out);
1283     return S_OK;
1284 }
1285
1286 static HRESULT sink_query_accept(struct strmbase_pin *base, const AM_MEDIA_TYPE *pmt)
1287 {
1288     if(IsEqualIID(&pmt->majortype, &MEDIATYPE_Audio) &&
1289             IsEqualIID(&pmt->formattype, &FORMAT_WaveFormatEx))
1290         return S_OK;
1291     if(IsEqualIID(&pmt->majortype, &MEDIATYPE_Interleaved) &&
1292             IsEqualIID(&pmt->formattype, &FORMAT_DvInfo))
1293         return S_OK;
1294     if(IsEqualIID(&pmt->majortype, &MEDIATYPE_Video) &&
1295             (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo) ||
1296              IsEqualIID(&pmt->formattype, &FORMAT_DvInfo)))
1297         return S_OK;
1298     return S_FALSE;
1299 }
1300
1301 static HRESULT WINAPI AviMuxIn_Receive(struct strmbase_sink *base, IMediaSample *pSample)
1302 {
1303     AviMux *avimux = impl_from_strmbase_filter(base->pin.filter);
1304     AviMuxIn *avimuxin = CONTAINING_RECORD(base, AviMuxIn, pin);
1305     REFERENCE_TIME start, stop;
1306     IMediaSample *sample;
1307     int frames_no;
1308     IMediaSample2 *ms2;
1309     BYTE *frame, *buf;
1310     DWORD max_size, size;
1311     DWORD flags;
1312     HRESULT hr;
1313
1314     TRACE("pin %p, pSample %p.\n", avimuxin, pSample);
1315
1316     hr = IMediaSample_QueryInterface(pSample, &IID_IMediaSample2, (void**)&ms2);
1317     if(SUCCEEDED(hr)) {
1318         AM_SAMPLE2_PROPERTIES props;
1319
1320         memset(&props, 0, sizeof(props));
1321         hr = IMediaSample2_GetProperties(ms2, sizeof(props), (BYTE*)&props);
1322         IMediaSample2_Release(ms2);
1323         if(FAILED(hr))
1324             return hr;
1325
1326         flags = props.dwSampleFlags;
1327         frame = props.pbBuffer;
1328         size = props.lActual;
1329     }else {
1330         flags = IMediaSample_IsSyncPoint(pSample) == S_OK ? AM_SAMPLE_SPLICEPOINT : 0;
1331         hr = IMediaSample_GetPointer(pSample, &frame);
1332         if(FAILED(hr))
1333             return hr;
1334         size = IMediaSample_GetActualDataLength(pSample);
1335     }
1336
1337     if(!avimuxin->pin.pin.mt.bTemporalCompression)
1338         flags |= AM_SAMPLE_SPLICEPOINT;
1339
1340     hr = IMediaSample_GetTime(pSample, &start, &stop);
1341     if(FAILED(hr))
1342         return hr;
1343
1344     if(avimuxin->stop>stop)
1345         return VFW_E_START_TIME_AFTER_END;
1346
1347     if(avimux->start == -1)
1348         avimux->start = start;
1349     if(avimux->stop < stop)
1350         avimux->stop = stop;
1351
1352     if(avimux->avih.dwSuggestedBufferSize < ALIGN(size)+sizeof(RIFFCHUNK))
1353         avimux->avih.dwSuggestedBufferSize = ALIGN(size) + sizeof(RIFFCHUNK);
1354     if(avimuxin->strh.dwSuggestedBufferSize < ALIGN(size)+sizeof(RIFFCHUNK))
1355         avimuxin->strh.dwSuggestedBufferSize = ALIGN(size) + sizeof(RIFFCHUNK);
1356
1357     frames_no = 1;
1358     if(avimuxin->stop!=-1 && start > avimuxin->stop) {
1359         frames_no += (double)(start - avimuxin->stop) / 10000000
1360                 * avimuxin->strh.dwRate / avimuxin->strh.dwScale + 0.5;
1361     }
1362     avimuxin->stop = stop;
1363
1364     while(--frames_no) {
1365         /* TODO: store all control frames in one buffer */
1366         hr = IMemAllocator_GetBuffer(avimuxin->samples_allocator, &sample, NULL, NULL, 0);
1367         if(FAILED(hr))
1368             return hr;
1369         hr = IMediaSample_SetActualDataLength(sample, 0);
1370         if(SUCCEEDED(hr))
1371             hr = IMediaSample_SetDiscontinuity(sample, TRUE);
1372         if(SUCCEEDED(hr))
1373             hr = IMediaSample_SetSyncPoint(sample, FALSE);
1374         if(SUCCEEDED(hr))
1375             hr = queue_sample(avimux, avimuxin, sample);
1376         IMediaSample_Release(sample);
1377         if(FAILED(hr))
1378             return hr;
1379     }
1380
1381     hr = IMemAllocator_GetBuffer(avimuxin->samples_allocator, &sample, NULL, NULL, 0);
1382     if(FAILED(hr))
1383         return hr;
1384     max_size = IMediaSample_GetSize(sample);
1385     if(size > max_size)
1386         size = max_size;
1387     hr = IMediaSample_SetActualDataLength(sample, size);
1388     if(SUCCEEDED(hr))
1389         hr = IMediaSample_SetDiscontinuity(sample, FALSE);
1390     if(SUCCEEDED(hr))
1391         hr = IMediaSample_SetSyncPoint(sample, flags & AM_SAMPLE_SPLICEPOINT);
1392     /* TODO: avoid unnecessary copying */
1393     if(SUCCEEDED(hr))
1394         hr = IMediaSample_GetPointer(sample, &buf);
1395     if(SUCCEEDED(hr)) {
1396         memcpy(buf, frame, size);
1397         hr = queue_sample(avimux, avimuxin, sample);
1398     }
1399     IMediaSample_Release(sample);
1400
1401     return hr;
1402 }
1403
1404 static HRESULT avi_mux_sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *pmt)
1405 {
1406     AviMuxIn *avimuxin = impl_sink_from_strmbase_pin(&iface->pin);
1407     AviMux *This = impl_from_strmbase_filter(iface->pin.filter);
1408     HRESULT hr;
1409
1410     if(!pmt)
1411         return E_POINTER;
1412
1413     if(IsEqualIID(&pmt->majortype, &MEDIATYPE_Video) &&
1414             IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) {
1415         ALLOCATOR_PROPERTIES req, act;
1416         VIDEOINFOHEADER *vih;
1417         int size;
1418
1419         vih = (VIDEOINFOHEADER*)pmt->pbFormat;
1420         avimuxin->strh.fcc = ckidSTREAMHEADER;
1421         avimuxin->strh.cb = sizeof(AVISTREAMHEADER) - FIELD_OFFSET(AVISTREAMHEADER, fccType);
1422         avimuxin->strh.fccType = streamtypeVIDEO;
1423         /* FIXME: fccHandler should be set differently */
1424         avimuxin->strh.fccHandler = vih->bmiHeader.biCompression ?
1425             vih->bmiHeader.biCompression : FCC('D','I','B',' ');
1426         avimuxin->avg_time_per_frame = vih->AvgTimePerFrame;
1427         avimuxin->stop = -1;
1428
1429         req.cBuffers = 32;
1430         req.cbBuffer = vih->bmiHeader.biSizeImage;
1431         req.cbAlign = 1;
1432         req.cbPrefix = sizeof(void*);
1433         hr = IMemAllocator_SetProperties(avimuxin->samples_allocator, &req, &act);
1434         if(SUCCEEDED(hr))
1435             hr = IMemAllocator_Commit(avimuxin->samples_allocator);
1436         if (FAILED(hr))
1437             return hr;
1438
1439         size = pmt->cbFormat - FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader);
1440         avimuxin->strf = malloc(sizeof(RIFFCHUNK) + ALIGN(FIELD_OFFSET(BITMAPINFO, bmiColors[vih->bmiHeader.biClrUsed])));
1441         avimuxin->strf->fcc = ckidSTREAMFORMAT;
1442         avimuxin->strf->cb = FIELD_OFFSET(BITMAPINFO, bmiColors[vih->bmiHeader.biClrUsed]);
1443         if(size > avimuxin->strf->cb)
1444             size = avimuxin->strf->cb;
1445         memcpy(avimuxin->strf->data, &vih->bmiHeader, size);
1446     }else {
1447         FIXME("format not supported: %s %s\n", debugstr_guid(&pmt->majortype),
1448                 debugstr_guid(&pmt->formattype));
1449         return E_NOTIMPL;
1450     }
1451
1452     return create_input_pin(This);
1453 }
1454
1455 static void avi_mux_sink_disconnect(struct strmbase_sink *iface)
1456 {
1457     AviMuxIn *avimuxin = impl_sink_from_strmbase_pin(&iface->pin);
1458     IMediaSample **prev, *cur;
1459
1460     IMemAllocator_Decommit(avimuxin->samples_allocator);
1461     while(avimuxin->samples_head) {
1462         cur = avimuxin->samples_head;
1463         if (FAILED(IMediaSample_GetPointer(cur, (BYTE **)&prev)))
1464             break;
1465         prev--;
1466
1467         cur = avimuxin->samples_head;
1468         avimuxin->samples_head = *prev;
1469         IMediaSample_Release(cur);
1470
1471         if(cur == avimuxin->samples_head)
1472             avimuxin->samples_head = NULL;
1473     }
1474     free(avimuxin->strf);
1475     avimuxin->strf = NULL;
1476 }
1477
1478 static const struct strmbase_sink_ops sink_ops =
1479 {
1480     .base.pin_query_interface = sink_query_interface,
1481     .base.pin_query_accept = sink_query_accept,
1482     .pfnReceive = AviMuxIn_Receive,
1483     .sink_connect = avi_mux_sink_connect,
1484     .sink_disconnect = avi_mux_sink_disconnect,
1485 };
1486
1487 static inline AviMux* impl_from_in_IPin(IPin *iface)
1488 {
1489     struct strmbase_pin *pin = CONTAINING_RECORD(iface, struct strmbase_pin, IPin_iface);
1490     return impl_from_strmbase_filter(pin->filter);
1491 }
1492
1493 static inline AviMuxIn* AviMuxIn_from_IAMStreamControl(IAMStreamControl *iface)
1494 {
1495     return CONTAINING_RECORD(iface, AviMuxIn, IAMStreamControl_iface);
1496 }
1497
1498 static HRESULT WINAPI AviMuxIn_AMStreamControl_QueryInterface(
1499         IAMStreamControl *iface, REFIID riid, void **ppv)
1500 {
1501     AviMuxIn *avimuxin = AviMuxIn_from_IAMStreamControl(iface);
1502     return IPin_QueryInterface(&avimuxin->pin.pin.IPin_iface, riid, ppv);
1503 }
1504
1505 static ULONG WINAPI AviMuxIn_AMStreamControl_AddRef(IAMStreamControl *iface)
1506 {
1507     AviMuxIn *avimuxin = AviMuxIn_from_IAMStreamControl(iface);
1508     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1509     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1510 }
1511
1512 static ULONG WINAPI AviMuxIn_AMStreamControl_Release(IAMStreamControl *iface)
1513 {
1514     AviMuxIn *avimuxin = AviMuxIn_from_IAMStreamControl(iface);
1515     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1516     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1517 }
1518
1519 static HRESULT WINAPI AviMuxIn_AMStreamControl_StartAt(IAMStreamControl *iface,
1520         const REFERENCE_TIME *start, DWORD cookie)
1521 {
1522     FIXME("iface %p, start %p, cookie %#lx, stub!\n", iface, start, cookie);
1523     return E_NOTIMPL;
1524 }
1525
1526 static HRESULT WINAPI AviMuxIn_AMStreamControl_StopAt(IAMStreamControl *iface,
1527         const REFERENCE_TIME *stop, BOOL send_extra, DWORD cookie)
1528 {
1529     FIXME("iface %p, stop %p, send_extra %d, cookie %#lx, stub!\n", iface, stop, send_extra, cookie);
1530     return E_NOTIMPL;
1531 }
1532
1533 static HRESULT WINAPI AviMuxIn_AMStreamControl_GetInfo(IAMStreamControl *iface,
1534         AM_STREAM_INFO *info)
1535 {
1536     FIXME("iface %p, info %p, stub!\n", iface, info);
1537     return E_NOTIMPL;
1538 }
1539
1540 static const IAMStreamControlVtbl AviMuxIn_AMStreamControlVtbl = {
1541     AviMuxIn_AMStreamControl_QueryInterface,
1542     AviMuxIn_AMStreamControl_AddRef,
1543     AviMuxIn_AMStreamControl_Release,
1544     AviMuxIn_AMStreamControl_StartAt,
1545     AviMuxIn_AMStreamControl_StopAt,
1546     AviMuxIn_AMStreamControl_GetInfo
1547 };
1548
1549 static inline AviMuxIn* AviMuxIn_from_IMemInputPin(IMemInputPin *iface)
1550 {
1551     return CONTAINING_RECORD(iface, AviMuxIn, pin.IMemInputPin_iface);
1552 }
1553
1554 static HRESULT WINAPI AviMuxIn_MemInputPin_QueryInterface(
1555         IMemInputPin *iface, REFIID riid, void **ppv)
1556 {
1557     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1558     return IPin_QueryInterface(&avimuxin->pin.pin.IPin_iface, riid, ppv);
1559 }
1560
1561 static ULONG WINAPI AviMuxIn_MemInputPin_AddRef(IMemInputPin *iface)
1562 {
1563     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1564     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1565     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1566 }
1567
1568 static ULONG WINAPI AviMuxIn_MemInputPin_Release(IMemInputPin *iface)
1569 {
1570     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1571     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1572     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1573 }
1574
1575 static HRESULT WINAPI AviMuxIn_MemInputPin_GetAllocator(
1576         IMemInputPin *iface, IMemAllocator **ppAllocator)
1577 {
1578     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1579
1580     TRACE("pin %p, ppAllocator %p.\n", avimuxin, ppAllocator);
1581
1582     if(!ppAllocator)
1583         return E_POINTER;
1584
1585     IMemAllocator_AddRef(avimuxin->pin.pAllocator);
1586     *ppAllocator = avimuxin->pin.pAllocator;
1587     return S_OK;
1588 }
1589
1590 static HRESULT WINAPI AviMuxIn_MemInputPin_NotifyAllocator(
1591         IMemInputPin *iface, IMemAllocator *pAllocator, BOOL bReadOnly)
1592 {
1593     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1594     ALLOCATOR_PROPERTIES props;
1595     HRESULT hr;
1596
1597     TRACE("pin %p, pAllocator %p, bReadOnly %d.\n", avimuxin, pAllocator, bReadOnly);
1598
1599     if(!pAllocator)
1600         return E_POINTER;
1601
1602     memset(&props, 0, sizeof(props));
1603     hr = IMemAllocator_GetProperties(pAllocator, &props);
1604     if(FAILED(hr))
1605         return hr;
1606
1607     props.cbAlign = 1;
1608     props.cbPrefix = 8;
1609     return IMemAllocator_SetProperties(avimuxin->pin.pAllocator, &props, &props);
1610 }
1611
1612 static HRESULT WINAPI AviMuxIn_MemInputPin_GetAllocatorRequirements(
1613         IMemInputPin *iface, ALLOCATOR_PROPERTIES *pProps)
1614 {
1615     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1616
1617     TRACE("pin %p, pProps %p.\n", avimuxin, pProps);
1618
1619     if(!pProps)
1620         return E_POINTER;
1621
1622     pProps->cbAlign = 1;
1623     pProps->cbPrefix = 8;
1624     return S_OK;
1625 }
1626
1627 static HRESULT WINAPI AviMuxIn_MemInputPin_Receive(
1628         IMemInputPin *iface, IMediaSample *pSample)
1629 {
1630     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1631
1632     TRACE("pin %p, pSample %p.\n", avimuxin, pSample);
1633
1634     return avimuxin->pin.pFuncsTable->pfnReceive(&avimuxin->pin, pSample);
1635 }
1636
1637 static HRESULT WINAPI AviMuxIn_MemInputPin_ReceiveMultiple(IMemInputPin *iface,
1638         IMediaSample **pSamples, LONG nSamples, LONG *nSamplesProcessed)
1639 {
1640     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1641     HRESULT hr = S_OK;
1642
1643     TRACE("pin %p, pSamples %p, nSamples %ld, nSamplesProcessed %p.\n",
1644             avimuxin, pSamples, nSamples, nSamplesProcessed);
1645
1646     for(*nSamplesProcessed=0; *nSamplesProcessed<nSamples; (*nSamplesProcessed)++)
1647     {
1648         hr = avimuxin->pin.pFuncsTable->pfnReceive(&avimuxin->pin, pSamples[*nSamplesProcessed]);
1649         if(hr != S_OK)
1650             break;
1651     }
1652
1653     return hr;
1654 }
1655
1656 static HRESULT WINAPI AviMuxIn_MemInputPin_ReceiveCanBlock(IMemInputPin *iface)
1657 {
1658     AviMuxIn *avimuxin = AviMuxIn_from_IMemInputPin(iface);
1659     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1660     HRESULT hr;
1661
1662     TRACE("avimuxin %p.\n", avimuxin);
1663
1664     if(!This->source.pMemInputPin)
1665         return S_FALSE;
1666
1667     hr = IMemInputPin_ReceiveCanBlock(This->source.pMemInputPin);
1668     return hr != S_FALSE ? S_OK : S_FALSE;
1669 }
1670
1671 static const IMemInputPinVtbl AviMuxIn_MemInputPinVtbl = {
1672     AviMuxIn_MemInputPin_QueryInterface,
1673     AviMuxIn_MemInputPin_AddRef,
1674     AviMuxIn_MemInputPin_Release,
1675     AviMuxIn_MemInputPin_GetAllocator,
1676     AviMuxIn_MemInputPin_NotifyAllocator,
1677     AviMuxIn_MemInputPin_GetAllocatorRequirements,
1678     AviMuxIn_MemInputPin_Receive,
1679     AviMuxIn_MemInputPin_ReceiveMultiple,
1680     AviMuxIn_MemInputPin_ReceiveCanBlock
1681 };
1682
1683 static inline AviMuxIn* AviMuxIn_from_IPropertyBag(IPropertyBag *iface)
1684 {
1685     return CONTAINING_RECORD(iface, AviMuxIn, IPropertyBag_iface);
1686 }
1687
1688 static HRESULT WINAPI AviMuxIn_PropertyBag_QueryInterface(
1689         IPropertyBag *iface, REFIID riid, void **ppv)
1690 {
1691     AviMuxIn *avimuxin = AviMuxIn_from_IPropertyBag(iface);
1692     return IPin_QueryInterface(&avimuxin->pin.pin.IPin_iface, riid, ppv);
1693 }
1694
1695 static ULONG WINAPI AviMuxIn_PropertyBag_AddRef(IPropertyBag *iface)
1696 {
1697     AviMuxIn *avimuxin = AviMuxIn_from_IPropertyBag(iface);
1698     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1699     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1700 }
1701
1702 static ULONG WINAPI AviMuxIn_PropertyBag_Release(IPropertyBag *iface)
1703 {
1704     AviMuxIn *avimuxin = AviMuxIn_from_IPropertyBag(iface);
1705     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1706     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1707 }
1708
1709 static HRESULT WINAPI AviMuxIn_PropertyBag_Read(IPropertyBag *iface,
1710         const WCHAR *name, VARIANT *value, IErrorLog *error_log)
1711 {
1712     FIXME("iface %p, name %s, value %p, error_log %p, stub!\n",
1713             iface, debugstr_w(name), value, error_log);
1714     return E_NOTIMPL;
1715 }
1716
1717 static HRESULT WINAPI AviMuxIn_PropertyBag_Write(IPropertyBag *iface,
1718         const WCHAR *name, VARIANT *value)
1719 {
1720     FIXME("iface %p, name %s, value %s, stub!\n",
1721             iface, debugstr_w(name), debugstr_variant(value));
1722     return E_NOTIMPL;
1723 }
1724
1725 static const IPropertyBagVtbl AviMuxIn_PropertyBagVtbl = {
1726     AviMuxIn_PropertyBag_QueryInterface,
1727     AviMuxIn_PropertyBag_AddRef,
1728     AviMuxIn_PropertyBag_Release,
1729     AviMuxIn_PropertyBag_Read,
1730     AviMuxIn_PropertyBag_Write
1731 };
1732
1733 static inline AviMuxIn* AviMuxIn_from_IQualityControl(IQualityControl *iface)
1734 {
1735     return CONTAINING_RECORD(iface, AviMuxIn, IQualityControl_iface);
1736 }
1737
1738 static HRESULT WINAPI AviMuxIn_QualityControl_QueryInterface(
1739         IQualityControl *iface, REFIID riid, void **ppv)
1740 {
1741     AviMuxIn *avimuxin = AviMuxIn_from_IQualityControl(iface);
1742     return IPin_QueryInterface(&avimuxin->pin.pin.IPin_iface, riid, ppv);
1743 }
1744
1745 static ULONG WINAPI AviMuxIn_QualityControl_AddRef(IQualityControl *iface)
1746 {
1747     AviMuxIn *avimuxin = AviMuxIn_from_IQualityControl(iface);
1748     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1749     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1750 }
1751
1752 static ULONG WINAPI AviMuxIn_QualityControl_Release(IQualityControl *iface)
1753 {
1754     AviMuxIn *avimuxin = AviMuxIn_from_IQualityControl(iface);
1755     AviMux *This = impl_from_in_IPin(&avimuxin->pin.pin.IPin_iface);
1756     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1757 }
1758
1759 static HRESULT WINAPI AviMuxIn_QualityControl_Notify(IQualityControl *iface,
1760         IBaseFilter *filter, Quality q)
1761 {
1762     FIXME("iface %p, filter %p, type %u, proportion %ld, late %s, timestamp %s, stub!\n",
1763             iface, filter, q.Type, q.Proportion, wine_dbgstr_longlong(q.Late),
1764             wine_dbgstr_longlong(q.TimeStamp));
1765     return E_NOTIMPL;
1766 }
1767
1768 static HRESULT WINAPI AviMuxIn_QualityControl_SetSink(IQualityControl *iface, IQualityControl *sink)
1769 {
1770     FIXME("iface %p, sink %p, stub!\n", iface, sink);
1771     return E_NOTIMPL;
1772 }
1773
1774 static const IQualityControlVtbl AviMuxIn_QualityControlVtbl = {
1775     AviMuxIn_QualityControl_QueryInterface,
1776     AviMuxIn_QualityControl_AddRef,
1777     AviMuxIn_QualityControl_Release,
1778     AviMuxIn_QualityControl_Notify,
1779     AviMuxIn_QualityControl_SetSink
1780 };
1781
1782 static HRESULT create_input_pin(AviMux *avimux)
1783 {
1784     AviMuxIn *object;
1785     WCHAR name[19];
1786     HRESULT hr;
1787
1788     if(avimux->input_pin_no >= MAX_PIN_NO-1)
1789         return E_FAIL;
1790
1791     swprintf(name, ARRAY_SIZE(name), L"Input %02u", avimux->input_pin_no + 1);
1792
1793     if (!(object = calloc(1, sizeof(*object))))
1794         return E_OUTOFMEMORY;
1795
1796     strmbase_sink_init(&object->pin, &avimux->filter, name, &sink_ops, NULL);
1797     object->pin.IMemInputPin_iface.lpVtbl = &AviMuxIn_MemInputPinVtbl;
1798     object->IAMStreamControl_iface.lpVtbl = &AviMuxIn_AMStreamControlVtbl;
1799     object->IPropertyBag_iface.lpVtbl = &AviMuxIn_PropertyBagVtbl;
1800     object->IQualityControl_iface.lpVtbl = &AviMuxIn_QualityControlVtbl;
1801
1802     hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER,
1803             &IID_IMemAllocator, (void **)&object->samples_allocator);
1804     if (FAILED(hr))
1805     {
1806         strmbase_sink_cleanup(&object->pin);
1807         free(object);
1808         return hr;
1809     }
1810
1811     hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER,
1812             &IID_IMemAllocator, (void **)&object->pin.pAllocator);
1813     if (FAILED(hr))
1814     {
1815         IMemAllocator_Release(object->samples_allocator);
1816         strmbase_sink_cleanup(&object->pin);
1817         free(object);
1818         return hr;
1819     }
1820
1821     object->indx = (AVISUPERINDEX *)&object->indx_data;
1822     object->ix = (AVISTDINDEX *)object->ix_data;
1823
1824     avimux->in[avimux->input_pin_no++] = object;
1825     return S_OK;
1826 }
1827
1828 HRESULT avi_mux_create(IUnknown *outer, IUnknown **out)
1829 {
1830     AviMux *avimux;
1831     HRESULT hr;
1832
1833     if (!(avimux = calloc(1, sizeof(AviMux))))
1834         return E_OUTOFMEMORY;
1835
1836     strmbase_filter_init(&avimux->filter, outer, &CLSID_AviDest, &filter_ops);
1837     avimux->IConfigAviMux_iface.lpVtbl = &ConfigAviMuxVtbl;
1838     avimux->IConfigInterleaving_iface.lpVtbl = &ConfigInterleavingVtbl;
1839     avimux->IMediaSeeking_iface.lpVtbl = &MediaSeekingVtbl;
1840     avimux->IPersistMediaPropertyBag_iface.lpVtbl = &PersistMediaPropertyBagVtbl;
1841     avimux->ISpecifyPropertyPages_iface.lpVtbl = &SpecifyPropertyPagesVtbl;
1842
1843     strmbase_source_init(&avimux->source, &avimux->filter, L"AVI Out", &source_ops);
1844     avimux->IQualityControl_iface.lpVtbl = &AviMuxOut_QualityControlVtbl;
1845     avimux->cur_stream = 0;
1846     avimux->cur_time = 0;
1847     avimux->stream = NULL;
1848
1849     hr = create_input_pin(avimux);
1850     if(FAILED(hr)) {
1851         strmbase_source_cleanup(&avimux->source);
1852         strmbase_filter_cleanup(&avimux->filter);
1853         free(avimux);
1854         return hr;
1855     }
1856
1857     avimux->interleave = 10000000;
1858
1859     TRACE("Created AVI mux %p.\n", avimux);
1860     *out = &avimux->filter.IUnknown_inner;
1861     return S_OK;
1862 }