8e6734180745adb4e4af609ad7b606d8933e1c5f
[reactos.git] / reactos / dll / directx / wine / quartz / avisplit.c
1 /*
2 * AVI Splitter Filter
3 *
4 * Copyright 2003 Robert Shearman
5 * Copyright 2004-2005 Christian Costa
6 * Copyright 2008 Maarten Lankhorst
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22 /* FIXME:
23 * - Reference leaks, if they still exist
24 * - Files without an index are not handled correctly yet.
25 * - When stopping/starting, a sample is lost. This should be compensated by
26 * keeping track of previous index/position.
27 * - Debugging channels are noisy at the moment, especially with thread
28 * related messages, however this is the only correct thing to do right now,
29 * since wine doesn't correctly handle all messages yet.
30 */
31
32 #include "quartz_private.h"
33 #include "pin.h"
34
35 //#include "uuids.h"
36 #include <vfw.h>
37 #include <aviriff.h>
38 //#include "vfwmsgs.h"
39 //#include "amvideo.h"
40
41 //#include <wine/unicode.h>
42 #include <wine/debug.h>
43
44 //#include <math.h>
45 #include <assert.h>
46
47 #include "parser.h"
48
49 #define TWOCCFromFOURCC(fcc) HIWORD(fcc)
50
51 /* four character codes used in AVI files */
52 #define ckidINFO mmioFOURCC('I','N','F','O')
53 #define ckidREC mmioFOURCC('R','E','C',' ')
54
55 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
56
57 typedef struct StreamData
58 {
59 DWORD dwSampleSize;
60 FLOAT fSamplesPerSec;
61 DWORD dwLength;
62
63 AVISTREAMHEADER streamheader;
64 DWORD entries;
65 AVISTDINDEX **stdindex;
66 DWORD frames;
67 DWORD seek;
68
69 /* Position, in index units */
70 DWORD pos, pos_next, index, index_next;
71
72 /* Packet handling: a thread is created and waits on the packet event handle
73 * On an event acquire the sample lock, addref the sample and set it to NULL,
74 * then queue a new packet.
75 */
76 HANDLE thread, packet_queued;
77 IMediaSample *sample;
78
79 /* Amount of preroll samples for this stream */
80 DWORD preroll;
81 } StreamData;
82
83 typedef struct AVISplitterImpl
84 {
85 ParserImpl Parser;
86 RIFFCHUNK CurrentChunk;
87 LONGLONG CurrentChunkOffset; /* in media time */
88 LONGLONG EndOfFile;
89 AVIMAINHEADER AviHeader;
90 AVIEXTHEADER ExtHeader;
91
92 AVIOLDINDEX *oldindex;
93 DWORD offset;
94
95 StreamData *streams;
96 } AVISplitterImpl;
97
98 struct thread_args {
99 AVISplitterImpl *This;
100 DWORD stream;
101 };
102
103 static inline AVISplitterImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
104 {
105 return CONTAINING_RECORD(iface, AVISplitterImpl, Parser.sourceSeeking.IMediaSeeking_iface);
106 }
107
108 /* The threading stuff cries for an explanation
109 *
110 * PullPin starts processing and calls AVISplitter_first_request
111 * AVISplitter_first_request creates a thread for each stream
112 * A stream can be audio, video, subtitles or something undefined.
113 *
114 * AVISplitter_first_request loads a single packet to each but one stream,
115 * and queues it for that last stream. This is to prevent WaitForNext to time
116 * out badly.
117 *
118 * The processing loop is entered. It calls IAsyncReader_WaitForNext in the
119 * PullPin. Every time it receives a packet, it will call AVISplitter_Sample
120 * AVISplitter_Sample will signal the relevant thread that a new sample is
121 * arrived, when that thread is ready it will read the packet and transmits
122 * it downstream with AVISplitter_Receive
123 *
124 * Threads terminate upon receiving NULL as packet or when ANY error code
125 * != S_OK occurs. This means that any error is fatal to processing.
126 */
127
128 static HRESULT AVISplitter_SendEndOfFile(AVISplitterImpl *This, DWORD streamnumber)
129 {
130 IPin* ppin = NULL;
131 HRESULT hr;
132
133 TRACE("End of file reached\n");
134
135 hr = IPin_ConnectedTo(This->Parser.ppPins[streamnumber+1], &ppin);
136 if (SUCCEEDED(hr))
137 {
138 hr = IPin_EndOfStream(ppin);
139 IPin_Release(ppin);
140 }
141 TRACE("--> %x\n", hr);
142
143 /* Force the pullpin thread to stop */
144 return S_FALSE;
145 }
146
147 /* Thread worker horse */
148 static HRESULT AVISplitter_next_request(AVISplitterImpl *This, DWORD streamnumber)
149 {
150 StreamData *stream = This->streams + streamnumber;
151 PullPin *pin = This->Parser.pInputPin;
152 IMediaSample *sample = NULL;
153 HRESULT hr;
154
155 TRACE("(%p, %u)->()\n", This, streamnumber);
156
157 hr = IMemAllocator_GetBuffer(pin->pAlloc, &sample, NULL, NULL, 0);
158 if (hr != S_OK)
159 ERR("... %08x?\n", hr);
160
161 if (SUCCEEDED(hr))
162 {
163 LONGLONG rtSampleStart;
164 /* Add 4 for the next header, which should hopefully work */
165 LONGLONG rtSampleStop;
166
167 stream->pos = stream->pos_next;
168 stream->index = stream->index_next;
169
170 IMediaSample_SetDiscontinuity(sample, stream->seek);
171 stream->seek = FALSE;
172 if (stream->preroll)
173 {
174 --stream->preroll;
175 IMediaSample_SetPreroll(sample, TRUE);
176 }
177 else
178 IMediaSample_SetPreroll(sample, FALSE);
179 IMediaSample_SetSyncPoint(sample, TRUE);
180
181 if (stream->stdindex)
182 {
183 AVISTDINDEX *index = stream->stdindex[stream->index];
184 AVISTDINDEX_ENTRY *entry = &index->aIndex[stream->pos];
185
186 /* End of file */
187 if (stream->index >= stream->entries)
188 {
189 TRACE("END OF STREAM ON %u\n", streamnumber);
190 IMediaSample_Release(sample);
191 return S_FALSE;
192 }
193
194 rtSampleStart = index->qwBaseOffset;
195 rtSampleStart += entry->dwOffset;
196 rtSampleStart = MEDIATIME_FROM_BYTES(rtSampleStart);
197
198 ++stream->pos_next;
199 if (index->nEntriesInUse == stream->pos_next)
200 {
201 stream->pos_next = 0;
202 ++stream->index_next;
203 }
204
205 rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(entry->dwSize & ~(1 << 31));
206
207 TRACE("offset(%u) size(%u)\n", (DWORD)BYTES_FROM_MEDIATIME(rtSampleStart), (DWORD)BYTES_FROM_MEDIATIME(rtSampleStop - rtSampleStart));
208 }
209 else if (This->oldindex)
210 {
211 DWORD flags = This->oldindex->aIndex[stream->pos].dwFlags;
212 DWORD size = This->oldindex->aIndex[stream->pos].dwSize;
213
214 /* End of file */
215 if (stream->index)
216 {
217 TRACE("END OF STREAM ON %u\n", streamnumber);
218 IMediaSample_Release(sample);
219 return S_FALSE;
220 }
221
222 rtSampleStart = MEDIATIME_FROM_BYTES(This->offset);
223 rtSampleStart += MEDIATIME_FROM_BYTES(This->oldindex->aIndex[stream->pos].dwOffset);
224 rtSampleStop = rtSampleStart + MEDIATIME_FROM_BYTES(size);
225 if (flags & AVIIF_MIDPART)
226 {
227 FIXME("Only stand alone frames are currently handled correctly!\n");
228 }
229 if (flags & AVIIF_LIST)
230 {
231 FIXME("Not sure if this is handled correctly\n");
232 rtSampleStart += MEDIATIME_FROM_BYTES(sizeof(RIFFLIST));
233 rtSampleStop += MEDIATIME_FROM_BYTES(sizeof(RIFFLIST));
234 }
235 else
236 {
237 rtSampleStart += MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK));
238 rtSampleStop += MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK));
239 }
240
241 /* Slow way of finding next index */
242 do {
243 stream->pos_next++;
244 } while (stream->pos_next * sizeof(This->oldindex->aIndex[0]) < This->oldindex->cb
245 && StreamFromFOURCC(This->oldindex->aIndex[stream->pos_next].dwChunkId) != streamnumber);
246
247 /* End of file soon */
248 if (stream->pos_next * sizeof(This->oldindex->aIndex[0]) >= This->oldindex->cb)
249 {
250 stream->pos_next = 0;
251 ++stream->index_next;
252 }
253 }
254 else /* TODO: Generate an index automagically */
255 {
256 ERR("CAN'T PLAY WITHOUT AN INDEX! SOS! SOS! SOS!\n");
257 assert(0);
258 }
259
260 if (rtSampleStart != rtSampleStop)
261 {
262 hr = IMediaSample_SetTime(sample, &rtSampleStart, &rtSampleStop);
263
264 hr = IAsyncReader_Request(pin->pReader, sample, streamnumber);
265
266 if (FAILED(hr))
267 assert(IMediaSample_Release(sample) == 0);
268 }
269 else
270 {
271 stream->sample = sample;
272 IMediaSample_SetActualDataLength(sample, 0);
273 SetEvent(stream->packet_queued);
274 }
275 }
276 else
277 {
278 if (sample)
279 {
280 ERR("There should be no sample!\n");
281 assert(IMediaSample_Release(sample) == 0);
282 }
283 }
284 TRACE("--> %08x\n", hr);
285
286 return hr;
287 }
288
289 static HRESULT AVISplitter_Receive(AVISplitterImpl *This, IMediaSample *sample, DWORD streamnumber)
290 {
291 Parser_OutputPin *pin = unsafe_impl_Parser_OutputPin_from_IPin(This->Parser.ppPins[1+streamnumber]);
292 HRESULT hr;
293 LONGLONG start, stop, rtstart, rtstop;
294 StreamData *stream = &This->streams[streamnumber];
295
296 start = pin->dwSamplesProcessed;
297 start *= stream->streamheader.dwScale;
298 start *= 10000000;
299 start /= stream->streamheader.dwRate;
300
301 if (stream->streamheader.dwSampleSize)
302 {
303 ULONG len = IMediaSample_GetActualDataLength(sample);
304 ULONG size = stream->streamheader.dwSampleSize;
305
306 pin->dwSamplesProcessed += len / size;
307 }
308 else
309 ++pin->dwSamplesProcessed;
310
311 stop = pin->dwSamplesProcessed;
312 stop *= stream->streamheader.dwScale;
313 stop *= 10000000;
314 stop /= stream->streamheader.dwRate;
315
316 if (IMediaSample_IsDiscontinuity(sample) == S_OK) {
317 IPin *victim;
318 EnterCriticalSection(&This->Parser.filter.csFilter);
319 pin->pin.pin.tStart = start;
320 pin->pin.pin.dRate = This->Parser.sourceSeeking.dRate;
321 hr = IPin_ConnectedTo(&pin->pin.pin.IPin_iface, &victim);
322 if (hr == S_OK)
323 {
324 hr = IPin_NewSegment(victim, start, This->Parser.sourceSeeking.llStop,
325 This->Parser.sourceSeeking.dRate);
326 if (hr != S_OK)
327 FIXME("NewSegment returns %08x\n", hr);
328 IPin_Release(victim);
329 }
330 LeaveCriticalSection(&This->Parser.filter.csFilter);
331 if (hr != S_OK)
332 return hr;
333 }
334 rtstart = (double)(start - pin->pin.pin.tStart) / pin->pin.pin.dRate;
335 rtstop = (double)(stop - pin->pin.pin.tStart) / pin->pin.pin.dRate;
336 hr = IMediaSample_SetMediaTime(sample, &start, &stop);
337 IMediaSample_SetTime(sample, &rtstart, &rtstop);
338 IMediaSample_SetMediaTime(sample, &start, &stop);
339
340 hr = BaseOutputPinImpl_Deliver(&pin->pin, sample);
341
342 /* Uncomment this if you want to debug the time differences between the
343 * different streams, it is useful for that
344 *
345 FIXME("stream %u, hr: %08x, Start: %u.%03u, Stop: %u.%03u\n", streamnumber, hr,
346 (DWORD)(start / 10000000), (DWORD)((start / 10000)%1000),
347 (DWORD)(stop / 10000000), (DWORD)((stop / 10000)%1000));
348 */
349 return hr;
350 }
351
352 static DWORD WINAPI AVISplitter_thread_reader(LPVOID data)
353 {
354 struct thread_args *args = data;
355 AVISplitterImpl *This = args->This;
356 DWORD streamnumber = args->stream;
357 HRESULT hr = S_OK;
358
359 do
360 {
361 HRESULT nexthr = S_FALSE;
362 IMediaSample *sample;
363
364 WaitForSingleObject(This->streams[streamnumber].packet_queued, INFINITE);
365 sample = This->streams[streamnumber].sample;
366 This->streams[streamnumber].sample = NULL;
367 if (!sample)
368 break;
369
370 nexthr = AVISplitter_next_request(This, streamnumber);
371
372 hr = AVISplitter_Receive(This, sample, streamnumber);
373 if (hr != S_OK)
374 FIXME("Receiving error: %08x\n", hr);
375
376 IMediaSample_Release(sample);
377 if (hr == S_OK)
378 hr = nexthr;
379 if (nexthr == S_FALSE)
380 AVISplitter_SendEndOfFile(This, streamnumber);
381 } while (hr == S_OK);
382
383 if (hr != S_FALSE)
384 FIXME("Thread %u terminated with hr %08x!\n", streamnumber, hr);
385 else
386 TRACE("Thread %u terminated properly\n", streamnumber);
387 return hr;
388 }
389
390 static HRESULT AVISplitter_Sample(LPVOID iface, IMediaSample * pSample, DWORD_PTR cookie)
391 {
392 AVISplitterImpl *This = iface;
393 StreamData *stream = This->streams + cookie;
394 HRESULT hr = S_OK;
395
396 if (!IMediaSample_GetActualDataLength(pSample))
397 {
398 ERR("Received empty sample\n");
399 return S_OK;
400 }
401
402 /* Send the sample to whatever thread is appropriate
403 * That thread should also not have a sample queued at the moment
404 */
405 /* Debugging */
406 TRACE("(%p)->(%p size: %u, %lu)\n", This, pSample, IMediaSample_GetActualDataLength(pSample), cookie);
407 assert(cookie < This->Parser.cStreams);
408 assert(!stream->sample);
409 assert(WaitForSingleObject(stream->packet_queued, 0) == WAIT_TIMEOUT);
410
411 IMediaSample_AddRef(pSample);
412
413 stream->sample = pSample;
414 SetEvent(stream->packet_queued);
415
416 return hr;
417 }
418
419 static HRESULT AVISplitter_done_process(LPVOID iface);
420
421 /* On the first request we have to be sure that (cStreams-1) samples have
422 * already been processed, because otherwise some pins might not ever finish
423 * a Pause state change
424 */
425 static HRESULT AVISplitter_first_request(LPVOID iface)
426 {
427 AVISplitterImpl *This = iface;
428 HRESULT hr = S_OK;
429 DWORD x;
430 IMediaSample *sample = NULL;
431 BOOL have_sample = FALSE;
432
433 TRACE("(%p)->()\n", This);
434
435 for (x = 0; x < This->Parser.cStreams; ++x)
436 {
437 StreamData *stream = This->streams + x;
438
439 /* Nothing should be running at this point */
440 assert(!stream->thread);
441
442 assert(!sample);
443 /* It could be we asked the thread to terminate, and the thread
444 * already terminated before receiving the deathwish */
445 ResetEvent(stream->packet_queued);
446
447 stream->pos_next = stream->pos;
448 stream->index_next = stream->index;
449
450 /* This was sent after stopped->paused or stopped->playing, so set seek */
451 stream->seek = 1;
452
453 /* There should be a packet queued from AVISplitter_next_request last time
454 * It needs to be done now because this is the only way to ensure that every
455 * stream will have at least 1 packet processed
456 * If this is done after the threads start it could go all awkward and we
457 * would have no guarantees that it's successful at all
458 */
459
460 if (have_sample)
461 {
462 DWORD_PTR dwUser = ~0;
463 hr = IAsyncReader_WaitForNext(This->Parser.pInputPin->pReader, 10000, &sample, &dwUser);
464 assert(hr == S_OK);
465 assert(sample);
466
467 AVISplitter_Sample(iface, sample, dwUser);
468 IMediaSample_Release(sample);
469 }
470
471 hr = AVISplitter_next_request(This, x);
472 TRACE("-->%08x\n", hr);
473
474 /* Could be an EOF instead */
475 have_sample = (hr == S_OK);
476 if (hr == S_FALSE)
477 AVISplitter_SendEndOfFile(This, x);
478
479 if (FAILED(hr) && hr != VFW_E_NOT_CONNECTED)
480 break;
481 hr = S_OK;
482 }
483
484 /* FIXME: Don't do this for each pin that sent an EOF */
485 for (x = 0; x < This->Parser.cStreams && SUCCEEDED(hr); ++x)
486 {
487 struct thread_args *args;
488 DWORD tid;
489
490 if ((This->streams[x].stdindex && This->streams[x].index_next >= This->streams[x].entries) ||
491 (!This->streams[x].stdindex && This->streams[x].index_next))
492 {
493 This->streams[x].thread = NULL;
494 continue;
495 }
496
497 args = CoTaskMemAlloc(sizeof(*args));
498 args->This = This;
499 args->stream = x;
500 This->streams[x].thread = CreateThread(NULL, 0, AVISplitter_thread_reader, args, 0, &tid);
501 TRACE("Created stream %u thread 0x%08x\n", x, tid);
502 }
503
504 if (FAILED(hr))
505 ERR("Horsemen of the apocalypse came to bring error 0x%08x\n", hr);
506
507 return hr;
508 }
509
510 static HRESULT AVISplitter_done_process(LPVOID iface)
511 {
512 AVISplitterImpl *This = iface;
513
514 DWORD x;
515
516 for (x = 0; x < This->Parser.cStreams; ++x)
517 {
518 StreamData *stream = This->streams + x;
519
520 TRACE("Waiting for %u to terminate\n", x);
521 /* Make the thread return first */
522 SetEvent(stream->packet_queued);
523 assert(WaitForSingleObject(stream->thread, 100000) != WAIT_TIMEOUT);
524 CloseHandle(stream->thread);
525 stream->thread = NULL;
526
527 if (stream->sample)
528 assert(IMediaSample_Release(stream->sample) == 0);
529 stream->sample = NULL;
530
531 ResetEvent(stream->packet_queued);
532 }
533 TRACE("All threads are now terminated\n");
534
535 return S_OK;
536 }
537
538 static HRESULT AVISplitter_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
539 {
540 if (IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream) && IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_Avi))
541 return S_OK;
542 return S_FALSE;
543 }
544
545 static HRESULT AVISplitter_ProcessIndex(AVISplitterImpl *This, AVISTDINDEX **index, LONGLONG qwOffset, DWORD cb)
546 {
547 AVISTDINDEX *pIndex;
548 DWORD x;
549 int rest;
550
551 *index = NULL;
552 if (cb < sizeof(AVISTDINDEX))
553 {
554 FIXME("size %u too small\n", cb);
555 return E_INVALIDARG;
556 }
557
558 pIndex = CoTaskMemAlloc(cb);
559 if (!pIndex)
560 return E_OUTOFMEMORY;
561
562 IAsyncReader_SyncRead((impl_PullPin_from_IPin(This->Parser.ppPins[0]))->pReader, qwOffset, cb, (BYTE *)pIndex);
563 rest = cb - sizeof(AVISUPERINDEX) + sizeof(RIFFCHUNK) + sizeof(pIndex->aIndex);
564
565 TRACE("FOURCC: %s\n", debugstr_an((char *)&pIndex->fcc, 4));
566 TRACE("wLongsPerEntry: %hd\n", pIndex->wLongsPerEntry);
567 TRACE("bIndexSubType: %u\n", pIndex->bIndexSubType);
568 TRACE("bIndexType: %u\n", pIndex->bIndexType);
569 TRACE("nEntriesInUse: %u\n", pIndex->nEntriesInUse);
570 TRACE("dwChunkId: %.4s\n", (char *)&pIndex->dwChunkId);
571 TRACE("qwBaseOffset: %x%08x\n", (DWORD)(pIndex->qwBaseOffset >> 32), (DWORD)pIndex->qwBaseOffset);
572 TRACE("dwReserved_3: %u\n", pIndex->dwReserved_3);
573
574 if (pIndex->bIndexType != AVI_INDEX_OF_CHUNKS
575 || pIndex->wLongsPerEntry != 2
576 || rest < (pIndex->nEntriesInUse * sizeof(DWORD) * pIndex->wLongsPerEntry)
577 || (pIndex->bIndexSubType != AVI_INDEX_SUB_DEFAULT))
578 {
579 FIXME("Invalid index chunk encountered: %u/%u, %u/%u, %u/%u, %u/%u\n",
580 pIndex->bIndexType, AVI_INDEX_OF_CHUNKS, pIndex->wLongsPerEntry, 2,
581 rest, (DWORD)(pIndex->nEntriesInUse * sizeof(DWORD) * pIndex->wLongsPerEntry),
582 pIndex->bIndexSubType, AVI_INDEX_SUB_DEFAULT);
583 *index = NULL;
584 return E_INVALIDARG;
585 }
586
587 for (x = 0; x < pIndex->nEntriesInUse; ++x)
588 {
589 BOOL keyframe = !(pIndex->aIndex[x].dwSize >> 31);
590 DWORDLONG offset = pIndex->qwBaseOffset + pIndex->aIndex[x].dwOffset;
591 TRACE("dwOffset: %x%08x\n", (DWORD)(offset >> 32), (DWORD)offset);
592 TRACE("dwSize: %u\n", (pIndex->aIndex[x].dwSize & ~(1<<31)));
593 TRACE("Frame is a keyframe: %s\n", keyframe ? "yes" : "no");
594 }
595
596 *index = pIndex;
597 return S_OK;
598 }
599
600 static HRESULT AVISplitter_ProcessOldIndex(AVISplitterImpl *This)
601 {
602 ULONGLONG mov_pos = BYTES_FROM_MEDIATIME(This->CurrentChunkOffset) - sizeof(DWORD);
603 AVIOLDINDEX *pAviOldIndex = This->oldindex;
604 int relative = -1;
605 DWORD x;
606
607 for (x = 0; x < pAviOldIndex->cb / sizeof(pAviOldIndex->aIndex[0]); ++x)
608 {
609 DWORD temp, temp2 = 0, offset, chunkid;
610 PullPin *pin = This->Parser.pInputPin;
611
612 offset = pAviOldIndex->aIndex[x].dwOffset;
613 chunkid = pAviOldIndex->aIndex[x].dwChunkId;
614
615 TRACE("dwChunkId: %.4s\n", (char *)&chunkid);
616 TRACE("dwFlags: %08x\n", pAviOldIndex->aIndex[x].dwFlags);
617 TRACE("dwOffset (%s): %08x\n", relative ? "relative" : "absolute", offset);
618 TRACE("dwSize: %08x\n", pAviOldIndex->aIndex[x].dwSize);
619
620 /* Only scan once, or else this will take too long */
621 if (relative == -1)
622 {
623 IAsyncReader_SyncRead(pin->pReader, offset, sizeof(DWORD), (BYTE *)&temp);
624 relative = (chunkid != temp);
625
626 if (chunkid == mmioFOURCC('7','F','x','x')
627 && ((char *)&temp)[0] == 'i' && ((char *)&temp)[1] == 'x')
628 relative = FALSE;
629
630 if (relative)
631 {
632 if (offset + mov_pos < BYTES_FROM_MEDIATIME(This->EndOfFile))
633 IAsyncReader_SyncRead(pin->pReader, offset + mov_pos, sizeof(DWORD), (BYTE *)&temp2);
634
635 if (chunkid == mmioFOURCC('7','F','x','x')
636 && ((char *)&temp2)[0] == 'i' && ((char *)&temp2)[1] == 'x')
637 {
638 /* Do nothing, all is great */
639 }
640 else if (temp2 != chunkid)
641 {
642 ERR("Faulty index or bug in handling: Wanted FCC: %s, Abs FCC: %s (@ %x), Rel FCC: %s (@ %.0x%08x)\n",
643 debugstr_an((char *)&chunkid, 4), debugstr_an((char *)&temp, 4), offset,
644 debugstr_an((char *)&temp2, 4), (DWORD)((mov_pos + offset) >> 32), (DWORD)(mov_pos + offset));
645 relative = -1;
646 }
647 else
648 TRACE("Scanned dwChunkId: %s\n", debugstr_an((char *)&temp2, 4));
649 }
650 else if (!relative)
651 TRACE("Scanned dwChunkId: %s\n", debugstr_an((char *)&temp, 4));
652 }
653 /* Only dump one packet */
654 else break;
655 }
656
657 if (relative == -1)
658 {
659 FIXME("Dropping index: no idea whether it is relative or absolute\n");
660 CoTaskMemFree(This->oldindex);
661 This->oldindex = NULL;
662 }
663 else if (!relative)
664 This->offset = 0;
665 else
666 This->offset = (DWORD)mov_pos;
667
668 return S_OK;
669 }
670
671 static HRESULT AVISplitter_ProcessStreamList(AVISplitterImpl * This, const BYTE * pData, DWORD cb, ALLOCATOR_PROPERTIES *props)
672 {
673 PIN_INFO piOutput;
674 const RIFFCHUNK * pChunk;
675 HRESULT hr;
676 AM_MEDIA_TYPE amt;
677 float fSamplesPerSec = 0.0f;
678 DWORD dwSampleSize = 0;
679 DWORD dwLength = 0;
680 DWORD nstdindex = 0;
681 static const WCHAR wszStreamTemplate[] = {'S','t','r','e','a','m',' ','%','0','2','d',0};
682 StreamData *stream;
683
684 ZeroMemory(&amt, sizeof(amt));
685 piOutput.dir = PINDIR_OUTPUT;
686 piOutput.pFilter = (IBaseFilter *)This;
687 wsprintfW(piOutput.achName, wszStreamTemplate, This->Parser.cStreams);
688 This->streams = CoTaskMemRealloc(This->streams, sizeof(StreamData) * (This->Parser.cStreams+1));
689 stream = This->streams + This->Parser.cStreams;
690 ZeroMemory(stream, sizeof(*stream));
691
692 for (pChunk = (const RIFFCHUNK *)pData;
693 ((const BYTE *)pChunk >= pData) && ((const BYTE *)pChunk + sizeof(RIFFCHUNK) < pData + cb) && (pChunk->cb > 0);
694 pChunk = (const RIFFCHUNK *)((const BYTE*)pChunk + sizeof(RIFFCHUNK) + pChunk->cb)
695 )
696 {
697 switch (pChunk->fcc)
698 {
699 case ckidSTREAMHEADER:
700 {
701 const AVISTREAMHEADER * pStrHdr = (const AVISTREAMHEADER *)pChunk;
702 TRACE("processing stream header\n");
703 stream->streamheader = *pStrHdr;
704
705 fSamplesPerSec = (float)pStrHdr->dwRate / (float)pStrHdr->dwScale;
706 CoTaskMemFree(amt.pbFormat);
707 amt.pbFormat = NULL;
708 amt.cbFormat = 0;
709
710 switch (pStrHdr->fccType)
711 {
712 case streamtypeVIDEO:
713 amt.formattype = FORMAT_VideoInfo;
714 break;
715 case streamtypeAUDIO:
716 amt.formattype = FORMAT_WaveFormatEx;
717 break;
718 default:
719 FIXME("fccType %.4s not handled yet\n", (const char *)&pStrHdr->fccType);
720 amt.formattype = FORMAT_None;
721 }
722 amt.majortype = MEDIATYPE_Video;
723 amt.majortype.Data1 = pStrHdr->fccType;
724 amt.subtype = MEDIATYPE_Video;
725 amt.subtype.Data1 = pStrHdr->fccHandler;
726 TRACE("Subtype FCC: %.04s\n", (LPCSTR)&pStrHdr->fccHandler);
727 amt.lSampleSize = pStrHdr->dwSampleSize;
728 amt.bFixedSizeSamples = (amt.lSampleSize != 0);
729
730 /* FIXME: Is this right? */
731 if (!amt.lSampleSize)
732 {
733 amt.lSampleSize = 1;
734 dwSampleSize = 1;
735 }
736
737 amt.bTemporalCompression = IsEqualGUID(&amt.majortype, &MEDIATYPE_Video); /* FIXME? */
738 dwSampleSize = pStrHdr->dwSampleSize;
739 dwLength = pStrHdr->dwLength;
740 if (!dwLength)
741 dwLength = This->AviHeader.dwTotalFrames;
742
743 if (pStrHdr->dwSuggestedBufferSize && pStrHdr->dwSuggestedBufferSize > props->cbBuffer)
744 props->cbBuffer = pStrHdr->dwSuggestedBufferSize;
745
746 break;
747 }
748 case ckidSTREAMFORMAT:
749 TRACE("processing stream format data\n");
750 if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo))
751 {
752 VIDEOINFOHEADER * pvi;
753 /* biCompression member appears to override the value in the stream header.
754 * i.e. the stream header can say something completely contradictory to what
755 * is in the BITMAPINFOHEADER! */
756 if (pChunk->cb < sizeof(BITMAPINFOHEADER))
757 {
758 ERR("Not enough bytes for BITMAPINFOHEADER\n");
759 return E_FAIL;
760 }
761 amt.cbFormat = sizeof(VIDEOINFOHEADER) - sizeof(BITMAPINFOHEADER) + pChunk->cb;
762 amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
763 ZeroMemory(amt.pbFormat, amt.cbFormat);
764 pvi = (VIDEOINFOHEADER *)amt.pbFormat;
765 pvi->AvgTimePerFrame = (LONGLONG)(10000000.0 / fSamplesPerSec);
766
767 CopyMemory(&pvi->bmiHeader, pChunk + 1, pChunk->cb);
768 if (pvi->bmiHeader.biCompression)
769 amt.subtype.Data1 = pvi->bmiHeader.biCompression;
770 }
771 else if (IsEqualIID(&amt.formattype, &FORMAT_WaveFormatEx))
772 {
773 amt.cbFormat = pChunk->cb;
774 if (amt.cbFormat < sizeof(WAVEFORMATEX))
775 amt.cbFormat = sizeof(WAVEFORMATEX);
776 amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
777 ZeroMemory(amt.pbFormat, amt.cbFormat);
778 CopyMemory(amt.pbFormat, pChunk + 1, pChunk->cb);
779 }
780 else
781 {
782 amt.cbFormat = pChunk->cb;
783 amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
784 CopyMemory(amt.pbFormat, pChunk + 1, amt.cbFormat);
785 }
786 break;
787 case ckidSTREAMNAME:
788 TRACE("processing stream name\n");
789 /* FIXME: this doesn't exactly match native version (we omit the "##)" prefix), but hey... */
790 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)(pChunk + 1), pChunk->cb, piOutput.achName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
791 break;
792 case ckidSTREAMHANDLERDATA:
793 FIXME("process stream handler data\n");
794 break;
795 case ckidAVIPADDING:
796 TRACE("JUNK chunk ignored\n");
797 break;
798 case ckidAVISUPERINDEX:
799 {
800 const AVISUPERINDEX *pIndex = (const AVISUPERINDEX *)pChunk;
801 DWORD x;
802 UINT rest = pIndex->cb - sizeof(AVISUPERINDEX) + sizeof(RIFFCHUNK) + sizeof(pIndex->aIndex[0]) * ANYSIZE_ARRAY;
803
804 if (pIndex->cb < sizeof(AVISUPERINDEX) - sizeof(RIFFCHUNK))
805 {
806 FIXME("size %u\n", pIndex->cb);
807 break;
808 }
809
810 if (nstdindex++ > 0)
811 {
812 ERR("Stream %d got more than 1 superindex?\n", This->Parser.cStreams);
813 break;
814 }
815
816 TRACE("wLongsPerEntry: %hd\n", pIndex->wLongsPerEntry);
817 TRACE("bIndexSubType: %u\n", pIndex->bIndexSubType);
818 TRACE("bIndexType: %u\n", pIndex->bIndexType);
819 TRACE("nEntriesInUse: %u\n", pIndex->nEntriesInUse);
820 TRACE("dwChunkId: %.4s\n", (const char *)&pIndex->dwChunkId);
821 if (pIndex->dwReserved[0])
822 TRACE("dwReserved[0]: %u\n", pIndex->dwReserved[0]);
823 if (pIndex->dwReserved[2])
824 TRACE("dwReserved[1]: %u\n", pIndex->dwReserved[1]);
825 if (pIndex->dwReserved[2])
826 TRACE("dwReserved[2]: %u\n", pIndex->dwReserved[2]);
827
828 if (pIndex->bIndexType != AVI_INDEX_OF_INDEXES
829 || pIndex->wLongsPerEntry != 4
830 || rest < (pIndex->nEntriesInUse * sizeof(DWORD) * pIndex->wLongsPerEntry)
831 || (pIndex->bIndexSubType != AVI_INDEX_SUB_2FIELD && pIndex->bIndexSubType != AVI_INDEX_SUB_DEFAULT))
832 {
833 FIXME("Invalid index chunk encountered\n");
834 break;
835 }
836
837 stream->entries = pIndex->nEntriesInUse;
838 stream->stdindex = CoTaskMemRealloc(stream->stdindex, sizeof(*stream->stdindex) * stream->entries);
839 for (x = 0; x < pIndex->nEntriesInUse; ++x)
840 {
841 TRACE("qwOffset: %x%08x\n", (DWORD)(pIndex->aIndex[x].qwOffset >> 32), (DWORD)pIndex->aIndex[x].qwOffset);
842 TRACE("dwSize: %u\n", pIndex->aIndex[x].dwSize);
843 TRACE("dwDuration: %u (unreliable)\n", pIndex->aIndex[x].dwDuration);
844
845 AVISplitter_ProcessIndex(This, &stream->stdindex[x], pIndex->aIndex[x].qwOffset, pIndex->aIndex[x].dwSize);
846 }
847 break;
848 }
849 default:
850 FIXME("unknown chunk type \"%.04s\" ignored\n", (LPCSTR)&pChunk->fcc);
851 }
852 }
853
854 if (IsEqualGUID(&amt.formattype, &FORMAT_WaveFormatEx))
855 {
856 amt.subtype = MEDIATYPE_Video;
857 amt.subtype.Data1 = ((WAVEFORMATEX *)amt.pbFormat)->wFormatTag;
858 }
859
860 dump_AM_MEDIA_TYPE(&amt);
861 TRACE("fSamplesPerSec = %f\n", (double)fSamplesPerSec);
862 TRACE("dwSampleSize = %x\n", dwSampleSize);
863 TRACE("dwLength = %x\n", dwLength);
864
865 stream->fSamplesPerSec = fSamplesPerSec;
866 stream->dwSampleSize = dwSampleSize;
867 stream->dwLength = dwLength; /* TODO: Use this for mediaseeking */
868 stream->packet_queued = CreateEventW(NULL, 0, 0, NULL);
869
870 hr = Parser_AddPin(&(This->Parser), &piOutput, props, &amt);
871 CoTaskMemFree(amt.pbFormat);
872
873
874 return hr;
875 }
876
877 static HRESULT AVISplitter_ProcessODML(AVISplitterImpl * This, const BYTE * pData, DWORD cb)
878 {
879 const RIFFCHUNK * pChunk;
880
881 for (pChunk = (const RIFFCHUNK *)pData;
882 ((const BYTE *)pChunk >= pData) && ((const BYTE *)pChunk + sizeof(RIFFCHUNK) < pData + cb) && (pChunk->cb > 0);
883 pChunk = (const RIFFCHUNK *)((const BYTE*)pChunk + sizeof(RIFFCHUNK) + pChunk->cb)
884 )
885 {
886 switch (pChunk->fcc)
887 {
888 case ckidAVIEXTHEADER:
889 {
890 int x;
891 const AVIEXTHEADER * pExtHdr = (const AVIEXTHEADER *)pChunk;
892
893 TRACE("processing extension header\n");
894 if (pExtHdr->cb != sizeof(AVIEXTHEADER) - sizeof(RIFFCHUNK))
895 {
896 FIXME("Size: %u\n", pExtHdr->cb);
897 break;
898 }
899 TRACE("dwGrandFrames: %u\n", pExtHdr->dwGrandFrames);
900 for (x = 0; x < 61; ++x)
901 if (pExtHdr->dwFuture[x])
902 FIXME("dwFuture[%i] = %u (0x%08x)\n", x, pExtHdr->dwFuture[x], pExtHdr->dwFuture[x]);
903 This->ExtHeader = *pExtHdr;
904 break;
905 }
906 default:
907 FIXME("unknown chunk type \"%.04s\" ignored\n", (LPCSTR)&pChunk->fcc);
908 }
909 }
910
911 return S_OK;
912 }
913
914 static HRESULT AVISplitter_InitializeStreams(AVISplitterImpl *This)
915 {
916 unsigned int x;
917
918 if (This->oldindex)
919 {
920 DWORD nMax, n;
921
922 for (x = 0; x < This->Parser.cStreams; ++x)
923 {
924 This->streams[x].frames = 0;
925 This->streams[x].pos = ~0;
926 This->streams[x].index = 0;
927 }
928
929 nMax = This->oldindex->cb / sizeof(This->oldindex->aIndex[0]);
930
931 /* Ok, maybe this is more of an exercise to see if I interpret everything correctly or not, but that is useful for now. */
932 for (n = 0; n < nMax; ++n)
933 {
934 DWORD streamId = StreamFromFOURCC(This->oldindex->aIndex[n].dwChunkId);
935 if (streamId >= This->Parser.cStreams)
936 {
937 FIXME("Stream id %s ignored\n", debugstr_an((char*)&This->oldindex->aIndex[n].dwChunkId, 4));
938 continue;
939 }
940 if (This->streams[streamId].pos == ~0U)
941 This->streams[streamId].pos = n;
942
943 if (This->streams[streamId].streamheader.dwSampleSize)
944 This->streams[streamId].frames += This->oldindex->aIndex[n].dwSize / This->streams[streamId].streamheader.dwSampleSize;
945 else
946 ++This->streams[streamId].frames;
947 }
948
949 for (x = 0; x < This->Parser.cStreams; ++x)
950 {
951 if ((DWORD)This->streams[x].frames != This->streams[x].streamheader.dwLength)
952 {
953 FIXME("stream %u: frames found: %u, frames meant to be found: %u\n", x, (DWORD)This->streams[x].frames, This->streams[x].streamheader.dwLength);
954 }
955 }
956
957 }
958 else if (!This->streams[0].entries)
959 {
960 for (x = 0; x < This->Parser.cStreams; ++x)
961 {
962 This->streams[x].frames = This->streams[x].streamheader.dwLength;
963 }
964 /* MS Avi splitter does seek through the whole file, we should! */
965 ERR("We should be manually seeking through the entire file to build an index, because the index is missing!!!\n");
966 return E_NOTIMPL;
967 }
968
969 /* Not much here yet */
970 for (x = 0; x < This->Parser.cStreams; ++x)
971 {
972 StreamData *stream = This->streams + x;
973 DWORD y;
974 DWORD64 frames = 0;
975
976 stream->seek = 1;
977
978 if (stream->stdindex)
979 {
980 stream->index = 0;
981 stream->pos = 0;
982 for (y = 0; y < stream->entries; ++y)
983 {
984 if (stream->streamheader.dwSampleSize)
985 {
986 DWORD z;
987
988 for (z = 0; z < stream->stdindex[y]->nEntriesInUse; ++z)
989 {
990 UINT len = stream->stdindex[y]->aIndex[z].dwSize & ~(1 << 31);
991 frames += len / stream->streamheader.dwSampleSize + !!(len % stream->streamheader.dwSampleSize);
992 }
993 }
994 else
995 frames += stream->stdindex[y]->nEntriesInUse;
996 }
997 }
998 else frames = stream->frames;
999
1000 frames *= stream->streamheader.dwScale;
1001 /* Keep accuracy as high as possible for duration */
1002 This->Parser.sourceSeeking.llDuration = frames * 10000000;
1003 This->Parser.sourceSeeking.llDuration /= stream->streamheader.dwRate;
1004 This->Parser.sourceSeeking.llStop = This->Parser.sourceSeeking.llDuration;
1005 This->Parser.sourceSeeking.llCurrent = 0;
1006
1007 frames /= stream->streamheader.dwRate;
1008
1009 TRACE("Duration: %d days, %d hours, %d minutes and %d.%03u seconds\n", (DWORD)(frames / 86400),
1010 (DWORD)((frames % 86400) / 3600), (DWORD)((frames % 3600) / 60), (DWORD)(frames % 60),
1011 (DWORD)(This->Parser.sourceSeeking.llDuration/10000) % 1000);
1012 }
1013
1014 return S_OK;
1015 }
1016
1017 static HRESULT AVISplitter_Disconnect(LPVOID iface);
1018
1019 /* FIXME: fix leaks on failure here */
1020 static HRESULT AVISplitter_InputPin_PreConnect(IPin * iface, IPin * pConnectPin, ALLOCATOR_PROPERTIES *props)
1021 {
1022 PullPin *This = impl_PullPin_from_IPin(iface);
1023 HRESULT hr;
1024 RIFFLIST list;
1025 LONGLONG pos = 0; /* in bytes */
1026 BYTE * pBuffer;
1027 RIFFCHUNK * pCurrentChunk;
1028 LONGLONG total, avail;
1029 ULONG x;
1030 DWORD indexes;
1031
1032 AVISplitterImpl * pAviSplit = (AVISplitterImpl *)This->pin.pinInfo.pFilter;
1033
1034 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
1035 pos += sizeof(list);
1036
1037 if (list.fcc != FOURCC_RIFF)
1038 {
1039 ERR("Input stream not a RIFF file\n");
1040 return E_FAIL;
1041 }
1042 if (list.fccListType != formtypeAVI)
1043 {
1044 ERR("Input stream not an AVI RIFF file\n");
1045 return E_FAIL;
1046 }
1047
1048 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
1049 if (list.fcc != FOURCC_LIST)
1050 {
1051 ERR("Expected LIST chunk, but got %.04s\n", (LPSTR)&list.fcc);
1052 return E_FAIL;
1053 }
1054 if (list.fccListType != listtypeAVIHEADER)
1055 {
1056 ERR("Header list expected. Got: %.04s\n", (LPSTR)&list.fccListType);
1057 return E_FAIL;
1058 }
1059
1060 pBuffer = HeapAlloc(GetProcessHeap(), 0, list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK));
1061 hr = IAsyncReader_SyncRead(This->pReader, pos + sizeof(list), list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK), pBuffer);
1062
1063 pAviSplit->AviHeader.cb = 0;
1064
1065 /* Stream list will set the buffer size here, so set a default and allow an override */
1066 props->cbBuffer = 0x20000;
1067
1068 for (pCurrentChunk = (RIFFCHUNK *)pBuffer; (BYTE *)pCurrentChunk + sizeof(*pCurrentChunk) < pBuffer + list.cb; pCurrentChunk = (RIFFCHUNK *)(((BYTE *)pCurrentChunk) + sizeof(*pCurrentChunk) + pCurrentChunk->cb))
1069 {
1070 RIFFLIST * pList;
1071
1072 switch (pCurrentChunk->fcc)
1073 {
1074 case ckidMAINAVIHEADER:
1075 /* AVIMAINHEADER includes the structure that is pCurrentChunk at the moment */
1076 memcpy(&pAviSplit->AviHeader, pCurrentChunk, sizeof(pAviSplit->AviHeader));
1077 break;
1078 case FOURCC_LIST:
1079 pList = (RIFFLIST *)pCurrentChunk;
1080 switch (pList->fccListType)
1081 {
1082 case ckidSTREAMLIST:
1083 hr = AVISplitter_ProcessStreamList(pAviSplit, (BYTE *)pCurrentChunk + sizeof(RIFFLIST), pCurrentChunk->cb + sizeof(RIFFCHUNK) - sizeof(RIFFLIST), props);
1084 break;
1085 case ckidODML:
1086 hr = AVISplitter_ProcessODML(pAviSplit, (BYTE *)pCurrentChunk + sizeof(RIFFLIST), pCurrentChunk->cb + sizeof(RIFFCHUNK) - sizeof(RIFFLIST));
1087 break;
1088 }
1089 break;
1090 case ckidAVIPADDING:
1091 /* ignore */
1092 break;
1093 default:
1094 FIXME("unrecognised header list type: %.04s\n", (LPSTR)&pCurrentChunk->fcc);
1095 }
1096 }
1097 HeapFree(GetProcessHeap(), 0, pBuffer);
1098
1099 if (pAviSplit->AviHeader.cb != sizeof(pAviSplit->AviHeader) - sizeof(RIFFCHUNK))
1100 {
1101 ERR("Avi Header wrong size!\n");
1102 return E_FAIL;
1103 }
1104
1105 pos += sizeof(RIFFCHUNK) + list.cb;
1106 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
1107
1108 while (list.fcc == ckidAVIPADDING || (list.fcc == FOURCC_LIST && list.fccListType != listtypeAVIMOVIE))
1109 {
1110 pos += sizeof(RIFFCHUNK) + list.cb;
1111
1112 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
1113 }
1114
1115 if (list.fcc != FOURCC_LIST)
1116 {
1117 ERR("Expected LIST, but got %.04s\n", (LPSTR)&list.fcc);
1118 return E_FAIL;
1119 }
1120 if (list.fccListType != listtypeAVIMOVIE)
1121 {
1122 ERR("Expected AVI movie list, but got %.04s\n", (LPSTR)&list.fccListType);
1123 return E_FAIL;
1124 }
1125
1126 IAsyncReader_Length(This->pReader, &total, &avail);
1127
1128 /* FIXME: AVIX files are extended beyond the FOURCC chunk "AVI ", and thus won't be played here,
1129 * once I get one of the files I'll try to fix it */
1130 if (hr == S_OK)
1131 {
1132 This->rtStart = pAviSplit->CurrentChunkOffset = MEDIATIME_FROM_BYTES(pos + sizeof(RIFFLIST));
1133 pos += list.cb + sizeof(RIFFCHUNK);
1134
1135 pAviSplit->EndOfFile = This->rtStop = MEDIATIME_FROM_BYTES(pos);
1136 if (pos > total)
1137 {
1138 ERR("File smaller (%x%08x) then EndOfFile (%x%08x)\n", (DWORD)(total >> 32), (DWORD)total, (DWORD)(pAviSplit->EndOfFile >> 32), (DWORD)pAviSplit->EndOfFile);
1139 return E_FAIL;
1140 }
1141
1142 hr = IAsyncReader_SyncRead(This->pReader, BYTES_FROM_MEDIATIME(pAviSplit->CurrentChunkOffset), sizeof(pAviSplit->CurrentChunk), (BYTE *)&pAviSplit->CurrentChunk);
1143 }
1144
1145 props->cbAlign = 1;
1146 props->cbPrefix = 0;
1147 /* Comrades, prevent shortage of buffers, or you will feel the consequences! DA! */
1148 props->cBuffers = 2 * pAviSplit->Parser.cStreams;
1149
1150 /* Now peek into the idx1 index, if available */
1151 if (hr == S_OK && (total - pos) > sizeof(RIFFCHUNK))
1152 {
1153 memset(&list, 0, sizeof(list));
1154
1155 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
1156 if (list.fcc == ckidAVIOLDINDEX)
1157 {
1158 pAviSplit->oldindex = CoTaskMemRealloc(pAviSplit->oldindex, list.cb + sizeof(RIFFCHUNK));
1159 if (pAviSplit->oldindex)
1160 {
1161 hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(RIFFCHUNK) + list.cb, (BYTE *)pAviSplit->oldindex);
1162 if (hr == S_OK)
1163 {
1164 hr = AVISplitter_ProcessOldIndex(pAviSplit);
1165 }
1166 else
1167 {
1168 CoTaskMemFree(pAviSplit->oldindex);
1169 pAviSplit->oldindex = NULL;
1170 hr = S_OK;
1171 }
1172 }
1173 }
1174 }
1175
1176 indexes = 0;
1177 for (x = 0; x < pAviSplit->Parser.cStreams; ++x)
1178 if (pAviSplit->streams[x].entries)
1179 ++indexes;
1180
1181 if (indexes)
1182 {
1183 CoTaskMemFree(pAviSplit->oldindex);
1184 pAviSplit->oldindex = NULL;
1185 if (indexes < pAviSplit->Parser.cStreams)
1186 {
1187 /* This error could possible be survived by switching to old type index,
1188 * but I would rather find out why it doesn't find everything here
1189 */
1190 ERR("%d indexes expected, but only have %d\n", indexes, pAviSplit->Parser.cStreams);
1191 indexes = 0;
1192 }
1193 }
1194 else if (!indexes && pAviSplit->oldindex)
1195 indexes = pAviSplit->Parser.cStreams;
1196
1197 if (!indexes && pAviSplit->AviHeader.dwFlags & AVIF_MUSTUSEINDEX)
1198 {
1199 FIXME("No usable index was found!\n");
1200 hr = E_FAIL;
1201 }
1202
1203 /* Now, set up the streams */
1204 if (hr == S_OK)
1205 hr = AVISplitter_InitializeStreams(pAviSplit);
1206
1207 if (hr != S_OK)
1208 {
1209 AVISplitter_Disconnect(pAviSplit);
1210 return E_FAIL;
1211 }
1212
1213 TRACE("AVI File ok\n");
1214
1215 return hr;
1216 }
1217
1218 static HRESULT AVISplitter_Flush(LPVOID iface)
1219 {
1220 AVISplitterImpl *This = iface;
1221 DWORD x;
1222
1223 TRACE("(%p)->()\n", This);
1224
1225 for (x = 0; x < This->Parser.cStreams; ++x)
1226 {
1227 StreamData *stream = This->streams + x;
1228
1229 if (stream->sample)
1230 assert(IMediaSample_Release(stream->sample) == 0);
1231 stream->sample = NULL;
1232
1233 ResetEvent(stream->packet_queued);
1234 assert(!stream->thread);
1235 }
1236
1237 return S_OK;
1238 }
1239
1240 static HRESULT AVISplitter_Disconnect(LPVOID iface)
1241 {
1242 AVISplitterImpl *This = iface;
1243 ULONG x;
1244
1245 /* TODO: Remove other memory that's allocated during connect */
1246 CoTaskMemFree(This->oldindex);
1247 This->oldindex = NULL;
1248
1249 for (x = 0; x < This->Parser.cStreams; ++x)
1250 {
1251 DWORD i;
1252
1253 StreamData *stream = &This->streams[x];
1254
1255 for (i = 0; i < stream->entries; ++i)
1256 CoTaskMemFree(stream->stdindex[i]);
1257
1258 CoTaskMemFree(stream->stdindex);
1259 CloseHandle(stream->packet_queued);
1260 }
1261 CoTaskMemFree(This->streams);
1262 This->streams = NULL;
1263 return S_OK;
1264 }
1265
1266 static ULONG WINAPI AVISplitter_Release(IBaseFilter *iface)
1267 {
1268 AVISplitterImpl *This = (AVISplitterImpl *)iface;
1269 ULONG ref;
1270
1271 ref = InterlockedDecrement(&This->Parser.filter.refCount);
1272
1273 TRACE("(%p)->() Release from %d\n", This, ref + 1);
1274
1275 if (!ref)
1276 {
1277 AVISplitter_Flush(This);
1278 Parser_Destroy(&This->Parser);
1279 }
1280
1281 return ref;
1282 }
1283
1284 static HRESULT WINAPI AVISplitter_seek(IMediaSeeking *iface)
1285 {
1286 AVISplitterImpl *This = impl_from_IMediaSeeking(iface);
1287 PullPin *pPin = This->Parser.pInputPin;
1288 LONGLONG newpos, endpos;
1289 DWORD x;
1290
1291 newpos = This->Parser.sourceSeeking.llCurrent;
1292 endpos = This->Parser.sourceSeeking.llDuration;
1293
1294 if (newpos > endpos)
1295 {
1296 WARN("Requesting position %x%08x beyond end of stream %x%08x\n", (DWORD)(newpos>>32), (DWORD)newpos, (DWORD)(endpos>>32), (DWORD)endpos);
1297 return E_INVALIDARG;
1298 }
1299
1300 FIXME("Moving position to %u.%03u s!\n", (DWORD)(newpos / 10000000), (DWORD)((newpos / 10000)%1000));
1301
1302 EnterCriticalSection(&pPin->thread_lock);
1303 /* Send a flush to all output pins */
1304 IPin_BeginFlush(&pPin->pin.IPin_iface);
1305
1306 /* Make sure this is done while stopped, BeginFlush takes care of this */
1307 EnterCriticalSection(&This->Parser.filter.csFilter);
1308 for (x = 0; x < This->Parser.cStreams; ++x)
1309 {
1310 Parser_OutputPin *pin = unsafe_impl_Parser_OutputPin_from_IPin(This->Parser.ppPins[1+x]);
1311 StreamData *stream = This->streams + x;
1312 LONGLONG wanted_frames;
1313 DWORD last_keyframe = 0, last_keyframeidx = 0, preroll = 0;
1314
1315 wanted_frames = newpos;
1316 wanted_frames *= stream->streamheader.dwRate;
1317 wanted_frames /= 10000000;
1318 wanted_frames /= stream->streamheader.dwScale;
1319
1320 pin->dwSamplesProcessed = 0;
1321 stream->index = 0;
1322 stream->pos = 0;
1323 stream->seek = 1;
1324 if (stream->stdindex)
1325 {
1326 DWORD y, z = 0;
1327
1328 for (y = 0; y < stream->entries; ++y)
1329 {
1330 for (z = 0; z < stream->stdindex[y]->nEntriesInUse; ++z)
1331 {
1332 if (stream->streamheader.dwSampleSize)
1333 {
1334 ULONG len = stream->stdindex[y]->aIndex[z].dwSize & ~(1 << 31);
1335 ULONG size = stream->streamheader.dwSampleSize;
1336
1337 pin->dwSamplesProcessed += len / size;
1338 if (len % size)
1339 ++pin->dwSamplesProcessed;
1340 }
1341 else ++pin->dwSamplesProcessed;
1342
1343 if (!(stream->stdindex[y]->aIndex[z].dwSize >> 31))
1344 {
1345 last_keyframe = z;
1346 last_keyframeidx = y;
1347 preroll = 0;
1348 }
1349 else
1350 ++preroll;
1351
1352 if (pin->dwSamplesProcessed >= wanted_frames)
1353 break;
1354 }
1355 if (pin->dwSamplesProcessed >= wanted_frames)
1356 break;
1357 }
1358 stream->index = last_keyframeidx;
1359 stream->pos = last_keyframe;
1360 }
1361 else
1362 {
1363 DWORD nMax, n;
1364 nMax = This->oldindex->cb / sizeof(This->oldindex->aIndex[0]);
1365
1366 for (n = 0; n < nMax; ++n)
1367 {
1368 DWORD streamId = StreamFromFOURCC(This->oldindex->aIndex[n].dwChunkId);
1369 if (streamId != x)
1370 continue;
1371
1372 if (stream->streamheader.dwSampleSize)
1373 {
1374 ULONG len = This->oldindex->aIndex[n].dwSize;
1375 ULONG size = stream->streamheader.dwSampleSize;
1376
1377 pin->dwSamplesProcessed += len / size;
1378 if (len % size)
1379 ++pin->dwSamplesProcessed;
1380 }
1381 else ++pin->dwSamplesProcessed;
1382
1383 if (This->oldindex->aIndex[n].dwFlags & AVIIF_KEYFRAME)
1384 {
1385 last_keyframe = n;
1386 preroll = 0;
1387 }
1388 else
1389 ++preroll;
1390
1391 if (pin->dwSamplesProcessed >= wanted_frames)
1392 break;
1393 }
1394 assert(n < nMax);
1395 stream->pos = last_keyframe;
1396 stream->index = 0;
1397 }
1398 stream->preroll = preroll;
1399 stream->seek = 1;
1400 }
1401 LeaveCriticalSection(&This->Parser.filter.csFilter);
1402
1403 TRACE("Done flushing\n");
1404 IPin_EndFlush(&pPin->pin.IPin_iface);
1405 LeaveCriticalSection(&pPin->thread_lock);
1406
1407 return S_OK;
1408 }
1409
1410 static const IBaseFilterVtbl AVISplitterImpl_Vtbl =
1411 {
1412 Parser_QueryInterface,
1413 Parser_AddRef,
1414 AVISplitter_Release,
1415 Parser_GetClassID,
1416 Parser_Stop,
1417 Parser_Pause,
1418 Parser_Run,
1419 Parser_GetState,
1420 Parser_SetSyncSource,
1421 Parser_GetSyncSource,
1422 Parser_EnumPins,
1423 Parser_FindPin,
1424 Parser_QueryFilterInfo,
1425 Parser_JoinFilterGraph,
1426 Parser_QueryVendorInfo
1427 };
1428
1429 HRESULT AVISplitter_create(IUnknown * pUnkOuter, LPVOID * ppv)
1430 {
1431 HRESULT hr;
1432 AVISplitterImpl * This;
1433
1434 TRACE("(%p, %p)\n", pUnkOuter, ppv);
1435
1436 *ppv = NULL;
1437
1438 if (pUnkOuter)
1439 return CLASS_E_NOAGGREGATION;
1440
1441 /* Note: This memory is managed by the transform filter once created */
1442 This = CoTaskMemAlloc(sizeof(AVISplitterImpl));
1443
1444 This->streams = NULL;
1445 This->oldindex = NULL;
1446
1447 hr = Parser_Create(&(This->Parser), &AVISplitterImpl_Vtbl, &CLSID_AviSplitter, AVISplitter_Sample, AVISplitter_QueryAccept, AVISplitter_InputPin_PreConnect, AVISplitter_Flush, AVISplitter_Disconnect, AVISplitter_first_request, AVISplitter_done_process, NULL, AVISplitter_seek, NULL);
1448
1449 if (FAILED(hr))
1450 return hr;
1451
1452 *ppv = This;
1453
1454 return hr;
1455 }