| /* |
| * AVI Splitter Filter |
| * |
| * Copyright 2003 Robert Shearman |
| * Copyright 2004-2005 Christian Costa |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| /* FIXME: |
| * - we don't do anything with indices yet (we could use them when seeking) |
| * - we don't support multiple RIFF sections (i.e. large AVI files > 2Gb) |
| */ |
| |
| #include "quartz_private.h" |
| #include "control_private.h" |
| #include "pin.h" |
| |
| #include "uuids.h" |
| #include "aviriff.h" |
| #include "mmreg.h" |
| #include "vfwmsgs.h" |
| #include "amvideo.h" |
| |
| #include "fourcc.h" |
| |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| #include <math.h> |
| #include <assert.h> |
| |
| #include "parser.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(quartz); |
| |
| typedef struct AVISplitterImpl |
| { |
| ParserImpl Parser; |
| IMediaSample * pCurrentSample; |
| RIFFCHUNK CurrentChunk; |
| LONGLONG CurrentChunkOffset; /* in media time */ |
| LONGLONG EndOfFile; |
| AVIMAINHEADER AviHeader; |
| } AVISplitterImpl; |
| |
| static HRESULT AVISplitter_NextChunk(LONGLONG * pllCurrentChunkOffset, RIFFCHUNK * pCurrentChunk, const REFERENCE_TIME * tStart, const REFERENCE_TIME * tStop, const BYTE * pbSrcStream, int inner) |
| { |
| if (inner) |
| *pllCurrentChunkOffset += MEDIATIME_FROM_BYTES(sizeof(RIFFLIST)); |
| else |
| *pllCurrentChunkOffset += MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK) + RIFFROUND(pCurrentChunk->cb)); |
| |
| if (*pllCurrentChunkOffset >= *tStop) |
| return S_FALSE; /* no more data - we couldn't even get the next chunk header! */ |
| else if (*pllCurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) >= *tStop) |
| { |
| memcpy(pCurrentChunk, pbSrcStream + (DWORD)BYTES_FROM_MEDIATIME(*pllCurrentChunkOffset - *tStart), (DWORD)BYTES_FROM_MEDIATIME(*tStop - *pllCurrentChunkOffset)); |
| return S_FALSE; /* no more data */ |
| } |
| else |
| memcpy(pCurrentChunk, pbSrcStream + (DWORD)BYTES_FROM_MEDIATIME(*pllCurrentChunkOffset - *tStart), sizeof(RIFFCHUNK)); |
| |
| return S_OK; |
| } |
| |
| static HRESULT AVISplitter_Sample(LPVOID iface, IMediaSample * pSample) |
| { |
| AVISplitterImpl *This = (AVISplitterImpl *)iface; |
| LPBYTE pbSrcStream = NULL; |
| long cbSrcStream = 0; |
| REFERENCE_TIME tStart, tStop; |
| HRESULT hr; |
| BOOL bMoreData = TRUE; |
| |
| hr = IMediaSample_GetPointer(pSample, &pbSrcStream); |
| |
| hr = IMediaSample_GetTime(pSample, &tStart, &tStop); |
| |
| cbSrcStream = IMediaSample_GetActualDataLength(pSample); |
| |
| /* trace removed for performance reasons */ |
| /* TRACE("(%p)\n", pSample); */ |
| |
| assert(BYTES_FROM_MEDIATIME(tStop - tStart) == cbSrcStream); |
| |
| if (This->CurrentChunkOffset <= tStart && This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) > tStart) |
| { |
| DWORD offset = (DWORD)BYTES_FROM_MEDIATIME(tStart - This->CurrentChunkOffset); |
| assert(offset <= sizeof(RIFFCHUNK)); |
| memcpy((BYTE *)&This->CurrentChunk + offset, pbSrcStream, sizeof(RIFFCHUNK) - offset); |
| } |
| else if (This->CurrentChunkOffset > tStart) |
| { |
| DWORD offset = (DWORD)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart); |
| if (offset >= (DWORD)cbSrcStream) |
| { |
| FIXME("large offset\n"); |
| hr = S_OK; |
| goto skip; |
| } |
| |
| memcpy(&This->CurrentChunk, pbSrcStream + offset, sizeof(RIFFCHUNK)); |
| } |
| |
| assert(This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) < tStop); |
| |
| while (bMoreData) |
| { |
| BYTE * pbDstStream; |
| long cbDstStream; |
| long chunk_remaining_bytes = 0; |
| long offset_src; |
| WORD streamId; |
| Parser_OutputPin * pOutputPin; |
| BOOL bSyncPoint = TRUE; |
| |
| if (This->CurrentChunkOffset >= tStart) |
| offset_src = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart) + sizeof(RIFFCHUNK); |
| else |
| offset_src = 0; |
| |
| switch (This->CurrentChunk.fcc) |
| { |
| case ckidJUNK: |
| case aviFCC('i','d','x','1'): /* Index is not handled */ |
| /* silently ignore */ |
| if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, FALSE)) |
| bMoreData = FALSE; |
| continue; |
| case ckidLIST: |
| /* We only handle the 'rec ' list which contains the stream data */ |
| if ((*(DWORD*)(pbSrcStream + BYTES_FROM_MEDIATIME(This->CurrentChunkOffset-tStart) + sizeof(RIFFCHUNK))) == aviFCC('r','e','c',' ')) |
| { |
| /* FIXME: We only advanced to the first chunk inside the list without keeping track that we are in it. |
| * This is not clean and the parser should be improved for that but it is enough for most AVI files. */ |
| if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, TRUE)) |
| { |
| bMoreData = FALSE; |
| continue; |
| } |
| This->CurrentChunk = *(RIFFCHUNK*) (pbSrcStream + BYTES_FROM_MEDIATIME(This->CurrentChunkOffset-tStart)); |
| offset_src = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart) + sizeof(RIFFCHUNK); |
| break; |
| } |
| else if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, FALSE)) |
| bMoreData = FALSE; |
| continue; |
| default: |
| break; |
| #if 0 /* According to the AVI specs, a stream data chunk should be ABXX where AB is the stream number and X means don't care */ |
| switch (TWOCCFromFOURCC(This->CurrentChunk.fcc)) |
| { |
| case cktypeDIBcompressed: |
| bSyncPoint = FALSE; |
| /* fall-through */ |
| case cktypeDIBbits: |
| /* FIXME: check that pin is of type video */ |
| break; |
| case cktypeWAVEbytes: |
| /* FIXME: check that pin is of type audio */ |
| break; |
| case cktypePALchange: |
| FIXME("handle palette change\n"); |
| break; |
| default: |
| FIXME("Skipping unknown chunk type: %s at file offset 0x%lx\n", debugstr_an((LPSTR)&This->CurrentChunk.fcc, 4), (DWORD)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset)); |
| if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, FALSE)) |
| bMoreData = FALSE; |
| continue; |
| } |
| #endif |
| } |
| |
| streamId = StreamFromFOURCC(This->CurrentChunk.fcc); |
| |
| if (streamId > This->Parser.cStreams) |
| { |
| ERR("Corrupted AVI file (contains stream id %d, but supposed to only have %ld streams)\n", streamId, This->Parser.cStreams); |
| hr = E_FAIL; |
| break; |
| } |
| |
| pOutputPin = (Parser_OutputPin *)This->Parser.ppPins[streamId + 1]; |
| |
| if (!This->pCurrentSample) |
| { |
| /* cache media sample until it is ready to be despatched |
| * (i.e. we reach the end of the chunk) */ |
| hr = OutputPin_GetDeliveryBuffer(&pOutputPin->pin, &This->pCurrentSample, NULL, NULL, 0); |
| |
| if (SUCCEEDED(hr)) |
| { |
| hr = IMediaSample_SetActualDataLength(This->pCurrentSample, 0); |
| assert(hr == S_OK); |
| } |
| else |
| { |
| TRACE("Skipping sending sample for stream %02d due to error (%lx)\n", streamId, hr); |
| This->pCurrentSample = NULL; |
| if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, FALSE)) |
| bMoreData = FALSE; |
| continue; |
| } |
| } |
| |
| hr = IMediaSample_GetPointer(This->pCurrentSample, &pbDstStream); |
| |
| if (SUCCEEDED(hr)) |
| { |
| cbDstStream = IMediaSample_GetSize(This->pCurrentSample); |
| |
| chunk_remaining_bytes = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(This->CurrentChunk.cb + sizeof(RIFFCHUNK)) - tStart) - offset_src; |
| |
| assert(chunk_remaining_bytes >= 0); |
| assert(chunk_remaining_bytes <= cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample)); |
| |
| /* trace removed for performance reasons */ |
| /* TRACE("chunk_remaining_bytes: 0x%lx, cbSrcStream: 0x%lx, offset_src: 0x%lx\n", chunk_remaining_bytes, cbSrcStream, offset_src); */ |
| } |
| |
| if (chunk_remaining_bytes <= cbSrcStream - offset_src) |
| { |
| if (SUCCEEDED(hr)) |
| { |
| memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, chunk_remaining_bytes); |
| hr = IMediaSample_SetActualDataLength(This->pCurrentSample, chunk_remaining_bytes + IMediaSample_GetActualDataLength(This->pCurrentSample)); |
| assert(hr == S_OK); |
| } |
| |
| if (SUCCEEDED(hr)) |
| { |
| REFERENCE_TIME tAviStart, tAviStop; |
| |
| /* FIXME: hack */ |
| if (pOutputPin->dwSamplesProcessed == 0) |
| IMediaSample_SetDiscontinuity(This->pCurrentSample, TRUE); |
| |
| IMediaSample_SetSyncPoint(This->pCurrentSample, bSyncPoint); |
| |
| pOutputPin->dwSamplesProcessed++; |
| |
| if (pOutputPin->dwSampleSize) |
| tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec)); |
| else |
| tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) / (float)pOutputPin->fSamplesPerSec); |
| if (pOutputPin->dwSampleSize) |
| tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec)); |
| else |
| tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed / (float)pOutputPin->fSamplesPerSec); |
| |
| IMediaSample_SetTime(This->pCurrentSample, &tAviStart, &tAviStop); |
| |
| hr = OutputPin_SendSample(&pOutputPin->pin, This->pCurrentSample); |
| if (hr != S_OK && hr != VFW_E_NOT_CONNECTED) |
| ERR("Error sending sample (%lx)\n", hr); |
| } |
| |
| if (This->pCurrentSample) |
| IMediaSample_Release(This->pCurrentSample); |
| |
| This->pCurrentSample = NULL; |
| |
| if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream, FALSE)) |
| bMoreData = FALSE; |
| } |
| else |
| { |
| if (SUCCEEDED(hr)) |
| { |
| memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, cbSrcStream - offset_src); |
| IMediaSample_SetActualDataLength(This->pCurrentSample, cbSrcStream - offset_src + IMediaSample_GetActualDataLength(This->pCurrentSample)); |
| } |
| bMoreData = FALSE; |
| } |
| } |
| |
| skip: |
| if (tStop >= This->EndOfFile) |
| { |
| int i; |
| |
| TRACE("End of file reached\n"); |
| |
| for (i = 0; i < This->Parser.cStreams; i++) |
| { |
| IPin* ppin; |
| HRESULT hr; |
| |
| TRACE("Send End Of Stream to output pin %d\n", i); |
| |
| hr = IPin_ConnectedTo(This->Parser.ppPins[i+1], &ppin); |
| if (SUCCEEDED(hr)) |
| { |
| hr = IPin_EndOfStream(ppin); |
| IPin_Release(ppin); |
| } |
| if (FAILED(hr)) |
| { |
| ERR("%lx\n", hr); |
| break; |
| } |
| } |
| |
| /* Force the pullpin thread to stop */ |
| hr = S_FALSE; |
| } |
| |
| return hr; |
| } |
| |
| static HRESULT AVISplitter_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt) |
| { |
| if (IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream) && IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_Avi)) |
| return S_OK; |
| return S_FALSE; |
| } |
| |
| static HRESULT AVISplitter_ProcessStreamList(AVISplitterImpl * This, const BYTE * pData, DWORD cb) |
| { |
| PIN_INFO piOutput; |
| const RIFFCHUNK * pChunk; |
| HRESULT hr; |
| AM_MEDIA_TYPE amt; |
| float fSamplesPerSec = 0.0f; |
| DWORD dwSampleSize = 0; |
| DWORD dwLength = 0; |
| ALLOCATOR_PROPERTIES props; |
| static const WCHAR wszStreamTemplate[] = {'S','t','r','e','a','m',' ','%','0','2','d',0}; |
| |
| props.cbAlign = 1; |
| props.cbPrefix = 0; |
| props.cbBuffer = 0x20000; |
| props.cBuffers = 2; |
| |
| ZeroMemory(&amt, sizeof(amt)); |
| piOutput.dir = PINDIR_OUTPUT; |
| piOutput.pFilter = (IBaseFilter *)This; |
| wsprintfW(piOutput.achName, wszStreamTemplate, This->Parser.cStreams); |
| |
| for (pChunk = (const RIFFCHUNK *)pData; |
| ((const BYTE *)pChunk >= pData) && ((const BYTE *)pChunk + sizeof(RIFFCHUNK) < pData + cb) && (pChunk->cb > 0); |
| pChunk = (const RIFFCHUNK *)((const BYTE*)pChunk + sizeof(RIFFCHUNK) + pChunk->cb) |
| ) |
| { |
| switch (pChunk->fcc) |
| { |
| case ckidSTREAMHEADER: |
| { |
| const AVISTREAMHEADER * pStrHdr = (const AVISTREAMHEADER *)pChunk; |
| TRACE("processing stream header\n"); |
| |
| fSamplesPerSec = (float)pStrHdr->dwRate / (float)pStrHdr->dwScale; |
| |
| switch (pStrHdr->fccType) |
| { |
| case streamtypeVIDEO: |
| memcpy(&amt.formattype, &FORMAT_VideoInfo, sizeof(GUID)); |
| amt.pbFormat = NULL; |
| amt.cbFormat = 0; |
| break; |
| case streamtypeAUDIO: |
| memcpy(&amt.formattype, &FORMAT_WaveFormatEx, sizeof(GUID)); |
| break; |
| default: |
| memcpy(&amt.formattype, &FORMAT_None, sizeof(GUID)); |
| } |
| memcpy(&amt.majortype, &MEDIATYPE_Video, sizeof(GUID)); |
| amt.majortype.Data1 = pStrHdr->fccType; |
| memcpy(&amt.subtype, &MEDIATYPE_Video, sizeof(GUID)); |
| amt.subtype.Data1 = pStrHdr->fccHandler; |
| TRACE("Subtype FCC: %.04s\n", (LPCSTR)&pStrHdr->fccHandler); |
| amt.lSampleSize = pStrHdr->dwSampleSize; |
| amt.bFixedSizeSamples = (amt.lSampleSize != 0); |
| |
| /* FIXME: Is this right? */ |
| if (!amt.lSampleSize) |
| { |
| amt.lSampleSize = 1; |
| dwSampleSize = 1; |
| } |
| |
| amt.bTemporalCompression = IsEqualGUID(&amt.majortype, &MEDIATYPE_Video); /* FIXME? */ |
| dwSampleSize = pStrHdr->dwSampleSize; |
| dwLength = pStrHdr->dwLength; |
| if (!dwLength) |
| dwLength = This->AviHeader.dwTotalFrames; |
| |
| if (pStrHdr->dwSuggestedBufferSize) |
| props.cbBuffer = pStrHdr->dwSuggestedBufferSize; |
| |
| break; |
| } |
| case ckidSTREAMFORMAT: |
| TRACE("processing stream format data\n"); |
| if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo)) |
| { |
| VIDEOINFOHEADER * pvi; |
| /* biCompression member appears to override the value in the stream header. |
| * i.e. the stream header can say something completely contradictory to what |
| * is in the BITMAPINFOHEADER! */ |
| if (pChunk->cb < sizeof(BITMAPINFOHEADER)) |
| { |
| ERR("Not enough bytes for BITMAPINFOHEADER\n"); |
| return E_FAIL; |
| } |
| amt.cbFormat = sizeof(VIDEOINFOHEADER) - sizeof(BITMAPINFOHEADER) + pChunk->cb; |
| amt.pbFormat = CoTaskMemAlloc(amt.cbFormat); |
| ZeroMemory(amt.pbFormat, amt.cbFormat); |
| pvi = (VIDEOINFOHEADER *)amt.pbFormat; |
| pvi->AvgTimePerFrame = (LONGLONG)(10000000.0 / fSamplesPerSec); |
| CopyMemory(&pvi->bmiHeader, (const BYTE *)(pChunk + 1), pChunk->cb); |
| if (pvi->bmiHeader.biCompression) |
| amt.subtype.Data1 = pvi->bmiHeader.biCompression; |
| } |
| else |
| { |
| amt.cbFormat = pChunk->cb; |
| amt.pbFormat = CoTaskMemAlloc(amt.cbFormat); |
| CopyMemory(amt.pbFormat, (const BYTE *)(pChunk + 1), amt.cbFormat); |
| } |
| break; |
| case ckidSTREAMNAME: |
| TRACE("processing stream name\n"); |
| /* FIXME: this doesn't exactly match native version (we omit the "##)" prefix), but hey... */ |
| MultiByteToWideChar(CP_ACP, 0, (LPCSTR)(pChunk + 1), pChunk->cb, piOutput.achName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0])); |
| break; |
| case ckidSTREAMHANDLERDATA: |
| FIXME("process stream handler data\n"); |
| break; |
| case ckidJUNK: |
| TRACE("JUNK chunk ignored\n"); |
| break; |
| default: |
| FIXME("unknown chunk type \"%.04s\" ignored\n", (LPCSTR)&pChunk->fcc); |
| } |
| } |
| |
| if (IsEqualGUID(&amt.formattype, &FORMAT_WaveFormatEx)) |
| { |
| memcpy(&amt.subtype, &MEDIATYPE_Video, sizeof(GUID)); |
| amt.subtype.Data1 = ((WAVEFORMATEX *)amt.pbFormat)->wFormatTag; |
| } |
| |
| dump_AM_MEDIA_TYPE(&amt); |
| TRACE("fSamplesPerSec = %f\n", (double)fSamplesPerSec); |
| TRACE("dwSampleSize = %lx\n", dwSampleSize); |
| TRACE("dwLength = %lx\n", dwLength); |
| |
| hr = Parser_AddPin(&(This->Parser), &piOutput, &props, &amt, fSamplesPerSec, dwSampleSize, dwLength); |
| |
| return hr; |
| } |
| |
| /* FIXME: fix leaks on failure here */ |
| static HRESULT AVISplitter_InputPin_PreConnect(IPin * iface, IPin * pConnectPin) |
| { |
| PullPin *This = (PullPin *)iface; |
| HRESULT hr; |
| RIFFLIST list; |
| LONGLONG pos = 0; /* in bytes */ |
| BYTE * pBuffer; |
| RIFFCHUNK * pCurrentChunk; |
| AVISplitterImpl * pAviSplit = (AVISplitterImpl *)This->pin.pinInfo.pFilter; |
| |
| hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list); |
| pos += sizeof(list); |
| |
| if (list.fcc != ckidRIFF) |
| { |
| ERR("Input stream not a RIFF file\n"); |
| return E_FAIL; |
| } |
| if (list.cb > 1 * 1024 * 1024 * 1024) /* cannot be more than 1Gb in size */ |
| { |
| ERR("Input stream violates RIFF spec\n"); |
| return E_FAIL; |
| } |
| if (list.fccListType != ckidAVI) |
| { |
| ERR("Input stream not an AVI RIFF file\n"); |
| return E_FAIL; |
| } |
| |
| hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list); |
| if (list.fcc != ckidLIST) |
| { |
| ERR("Expected LIST chunk, but got %.04s\n", (LPSTR)&list.fcc); |
| return E_FAIL; |
| } |
| if (list.fccListType != ckidHEADERLIST) |
| { |
| ERR("Header list expected. Got: %.04s\n", (LPSTR)&list.fccListType); |
| return E_FAIL; |
| } |
| |
| pBuffer = HeapAlloc(GetProcessHeap(), 0, list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK)); |
| hr = IAsyncReader_SyncRead(This->pReader, pos + sizeof(list), list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK), pBuffer); |
| |
| pAviSplit->AviHeader.cb = 0; |
| |
| for (pCurrentChunk = (RIFFCHUNK *)pBuffer; (BYTE *)pCurrentChunk + sizeof(*pCurrentChunk) < pBuffer + list.cb; pCurrentChunk = (RIFFCHUNK *)(((BYTE *)pCurrentChunk) + sizeof(*pCurrentChunk) + pCurrentChunk->cb)) |
| { |
| RIFFLIST * pList; |
| |
| switch (pCurrentChunk->fcc) |
| { |
| case ckidMAINAVIHEADER: |
| /* AVIMAINHEADER includes the structure that is pCurrentChunk at the moment */ |
| memcpy(&pAviSplit->AviHeader, pCurrentChunk, sizeof(pAviSplit->AviHeader)); |
| break; |
| case ckidLIST: |
| pList = (RIFFLIST *)pCurrentChunk; |
| switch (pList->fccListType) |
| { |
| case ckidSTREAMLIST: |
| hr = AVISplitter_ProcessStreamList(pAviSplit, (BYTE *)pCurrentChunk + sizeof(RIFFLIST), pCurrentChunk->cb + sizeof(RIFFCHUNK) - sizeof(RIFFLIST)); |
| break; |
| case ckidODML: |
| FIXME("process ODML header\n"); |
| break; |
| } |
| break; |
| case ckidJUNK: |
| /* ignore */ |
| break; |
| default: |
| FIXME("unrecognised header list type: %.04s\n", (LPSTR)&pCurrentChunk->fcc); |
| } |
| } |
| HeapFree(GetProcessHeap(), 0, pBuffer); |
| |
| if (pAviSplit->AviHeader.cb != sizeof(pAviSplit->AviHeader) - sizeof(RIFFCHUNK)) |
| { |
| ERR("Avi Header wrong size!\n"); |
| return E_FAIL; |
| } |
| |
| pos += sizeof(RIFFCHUNK) + list.cb; |
| hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list); |
| |
| if (list.fcc == ckidJUNK) |
| { |
| pos += sizeof(RIFFCHUNK) + list.cb; |
| hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list); |
| } |
| |
| if (list.fcc != ckidLIST) |
| { |
| ERR("Expected LIST, but got %.04s\n", (LPSTR)&list.fcc); |
| return E_FAIL; |
| } |
| if (list.fccListType != ckidAVIMOVIE) |
| { |
| ERR("Expected AVI movie list, but got %.04s\n", (LPSTR)&list.fccListType); |
| return E_FAIL; |
| } |
| |
| if (hr == S_OK) |
| { |
| pAviSplit->CurrentChunkOffset = MEDIATIME_FROM_BYTES(pos + sizeof(RIFFLIST)); |
| pAviSplit->EndOfFile = MEDIATIME_FROM_BYTES(pos + list.cb + sizeof(RIFFLIST)); |
| hr = IAsyncReader_SyncRead(This->pReader, BYTES_FROM_MEDIATIME(pAviSplit->CurrentChunkOffset), sizeof(pAviSplit->CurrentChunk), (BYTE *)&pAviSplit->CurrentChunk); |
| } |
| |
| if (hr != S_OK) |
| return E_FAIL; |
| |
| TRACE("AVI File ok\n"); |
| |
| return hr; |
| } |
| |
| HRESULT AVISplitter_create(IUnknown * pUnkOuter, LPVOID * ppv) |
| { |
| HRESULT hr; |
| AVISplitterImpl * This; |
| |
| TRACE("(%p, %p)\n", pUnkOuter, ppv); |
| |
| *ppv = NULL; |
| |
| if (pUnkOuter) |
| return CLASS_E_NOAGGREGATION; |
| |
| /* Note: This memory is managed by the transform filter once created */ |
| This = CoTaskMemAlloc(sizeof(AVISplitterImpl)); |
| |
| This->pCurrentSample = NULL; |
| |
| hr = Parser_Create(&(This->Parser), &CLSID_AviSplitter, AVISplitter_Sample, AVISplitter_QueryAccept, AVISplitter_InputPin_PreConnect); |
| |
| if (FAILED(hr)) |
| return hr; |
| |
| *ppv = (LPVOID)This; |
| |
| return hr; |
| } |