ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/quartz/aviparse.c

721 lines
20 KiB
C
Raw Blame History

/*
* Implements AVI Parser(Splitter).
*
* FIXME - no seeking
*
* Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
*
* 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
*/
#include "config.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmsystem.h"
#include "vfw.h"
#include "winerror.h"
#include "strmif.h"
#include "control.h"
#include "vfwmsgs.h"
#include "amvideo.h"
#include "uuids.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(quartz);
#include "quartz_private.h"
#include "parser.h"
#include "mtype.h"
static const WCHAR QUARTZ_AVIParser_Name[] =
{ 'A','V','I',' ','S','p','l','i','t','t','e','r',0 };
static const WCHAR QUARTZ_AVIParserInPin_Name[] =
{ 'I','n',0 };
static const WCHAR QUARTZ_AVIParserOutPin_Basename[] =
{ 'S','t','r','e','a','m',0 };
#define WINE_QUARTZ_AVIPINNAME_MAX 64
/****************************************************************************
*
* CAVIParseImpl
*/
typedef struct CAVIParseImpl CAVIParseImpl;
typedef struct CAVIParseStream CAVIParseStream;
struct CAVIParseImpl
{
MainAVIHeader avih;
CAVIParseStream* pStreamsBuf;
DWORD cIndexEntries;
AVIINDEXENTRY* pIndexEntriesBuf;
WCHAR wchWork[ WINE_QUARTZ_AVIPINNAME_MAX ];
};
struct CAVIParseStream
{
AVIStreamHeader strh;
DWORD cbFmt;
BYTE* pFmtBuf;
DWORD cIndexEntries;
AVIINDEXENTRY* pIndexEntries;
DWORD cIndexCur;
REFERENCE_TIME rtCur;
REFERENCE_TIME rtInternal;
BOOL bDataDiscontinuity;
};
static HRESULT CAVIParseImpl_ParseStreamList(
CParserImpl* pImpl, CAVIParseImpl* This, ULONG nStreamIndex,
LONGLONG llOfsTop, DWORD dwListLen, CAVIParseStream* pStream )
{
HRESULT hr;
LONGLONG llOfs;
DWORD dwChunkLength;
TRACE("search strh\n");
hr = RIFF_SearchChunk(
pImpl, dwListLen,
llOfsTop, PARSER_strh,
&llOfs, &dwChunkLength );
if ( hr == S_OK )
{
TRACE("strh has been detected\n");
if ( dwChunkLength < sizeof(AVIStreamHeader) )
hr = E_FAIL;
else
hr = IAsyncReader_SyncRead( pImpl->m_pReader,
llOfs, sizeof(AVIStreamHeader), (BYTE*)&pStream->strh );
}
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
TRACE("search strf\n");
hr = RIFF_SearchChunk(
pImpl, dwListLen,
llOfsTop, PARSER_strf,
&llOfs, &dwChunkLength );
if ( hr == S_OK && dwChunkLength > 0 )
{
TRACE("strf has been detected\n");
pStream->cbFmt = dwChunkLength;
pStream->pFmtBuf = (BYTE*)QUARTZ_AllocMem( dwChunkLength );
if ( pStream->pFmtBuf == NULL )
hr = E_OUTOFMEMORY;
else
hr = IAsyncReader_SyncRead( pImpl->m_pReader,
llOfs, dwChunkLength, pStream->pFmtBuf );
}
if ( FAILED(hr) )
return hr;
TRACE("search indx\n");
hr = RIFF_SearchChunk(
pImpl, dwListLen,
llOfsTop, PARSER_indx,
&llOfs, &dwChunkLength );
if ( FAILED(hr) )
return hr;
if ( hr == S_OK )
{
FIXME( "'indx' has been detected - not implemented now!\n" );
return E_FAIL;
}
return NOERROR;
}
static HRESULT CAVIParseImpl_InitParser( CParserImpl* pImpl, ULONG* pcStreams )
{
CAVIParseImpl* This = NULL;
BYTE riffhdr[12];
ULONG i;
ULONG nIndex;
HRESULT hr;
LONGLONG llOfs_hdrl;
DWORD dwLen_hdrl;
LONGLONG llOfs;
DWORD dwChunkId;
DWORD dwChunkLength;
AVIINDEXENTRY* pEntriesBuf = NULL;
ULONG cEntries;
ULONG cEntriesCur;
TRACE("(%p,%p)\n",pImpl,pcStreams);
hr = IAsyncReader_SyncRead( pImpl->m_pReader, 0, 12, riffhdr );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
if ( memcmp( &riffhdr[0], "RIFF", 4 ) != 0 ||
memcmp( &riffhdr[8], "AVI ", 4 ) != 0 )
return E_FAIL;
TRACE("it's AVI\n");
This = (CAVIParseImpl*)QUARTZ_AllocMem( sizeof(CAVIParseImpl) );
if ( This == NULL )
return E_OUTOFMEMORY;
pImpl->m_pUserData = This;
ZeroMemory( This, sizeof(CAVIParseImpl) );
This->pStreamsBuf = NULL;
This->cIndexEntries = 0;
This->pIndexEntriesBuf = 0;
hr = RIFF_SearchList(
pImpl, (DWORD)0xffffffff,
PARSER_RIFF_OfsFirst, PARSER_hdrl,
&llOfs_hdrl, &dwLen_hdrl );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
/* read 'avih' */
TRACE("read avih\n");
hr = RIFF_SearchChunk(
pImpl, dwLen_hdrl,
llOfs_hdrl, PARSER_avih,
&llOfs, &dwChunkLength );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
if ( dwChunkLength > sizeof(MainAVIHeader) )
dwChunkLength = sizeof(MainAVIHeader);
hr = IAsyncReader_SyncRead( pImpl->m_pReader, llOfs, dwChunkLength, (BYTE*)&(This->avih) );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
if ( This->avih.dwStreams == 0 )
return E_FAIL;
/* initialize streams. */
This->pStreamsBuf = (CAVIParseStream*)QUARTZ_AllocMem(
sizeof(CAVIParseStream) * This->avih.dwStreams );
if ( This->pStreamsBuf == NULL )
return E_OUTOFMEMORY;
ZeroMemory( This->pStreamsBuf,
sizeof(CAVIParseStream) * This->avih.dwStreams );
llOfs = llOfs_hdrl;
for ( nIndex = 0; nIndex < This->avih.dwStreams; nIndex++ )
{
TRACE("search strl for stream %lu\n",nIndex);
hr = RIFF_SearchList(
pImpl,
dwLen_hdrl, llOfs, PARSER_strl,
&llOfs, &dwChunkLength );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
/* read 'strl'. */
hr = CAVIParseImpl_ParseStreamList(
pImpl, This, nIndex,
llOfs, dwChunkLength, &This->pStreamsBuf[nIndex] );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
llOfs += dwChunkLength;
}
/* initialize idx1. */
TRACE("search idx1\n");
hr = RIFF_SearchChunk(
pImpl, (DWORD)0xffffffff,
PARSER_RIFF_OfsFirst, PARSER_idx1,
&llOfs, &dwChunkLength );
if ( FAILED(hr) )
return hr;
if ( hr == S_OK )
{
/* read idx1. */
This->cIndexEntries = dwChunkLength / sizeof(AVIINDEXENTRY);
This->pIndexEntriesBuf = (AVIINDEXENTRY*)QUARTZ_AllocMem(
sizeof(AVIINDEXENTRY) * This->cIndexEntries );
if ( This->pIndexEntriesBuf == NULL )
return E_OUTOFMEMORY;
hr = IAsyncReader_SyncRead( pImpl->m_pReader, llOfs, sizeof(AVIINDEXENTRY) * This->cIndexEntries, (BYTE*)This->pIndexEntriesBuf );
if ( FAILED(hr) )
return hr;
if ( hr != S_OK )
return E_FAIL;
pEntriesBuf = (AVIINDEXENTRY*)QUARTZ_AllocMem(
sizeof(AVIINDEXENTRY) * This->cIndexEntries );
if ( pEntriesBuf == NULL )
return E_OUTOFMEMORY;
cEntries = 0;
for ( nIndex = 0; nIndex < This->avih.dwStreams; nIndex++ )
{
cEntriesCur = cEntries;
dwChunkId = (((nIndex%10)+'0')<<8) | ((nIndex/10)+'0');
for ( i = 0; i < This->cIndexEntries; i++ )
{
if ( (This->pIndexEntriesBuf[i].ckid & 0xffff) == dwChunkId )
memcpy( &pEntriesBuf[cEntries++], &This->pIndexEntriesBuf[i], sizeof(AVIINDEXENTRY) );
}
This->pStreamsBuf[nIndex].pIndexEntries = &pEntriesBuf[cEntriesCur];
This->pStreamsBuf[nIndex].cIndexEntries = cEntries - cEntriesCur;
This->pStreamsBuf[nIndex].cIndexCur = 0;
This->pStreamsBuf[nIndex].rtCur = 0;
This->pStreamsBuf[nIndex].rtInternal = 0;
TRACE("stream %lu - %lu entries\n",nIndex,This->pStreamsBuf[nIndex].cIndexEntries);
This->pStreamsBuf[nIndex].bDataDiscontinuity = TRUE;
}
QUARTZ_FreeMem(This->pIndexEntriesBuf);
This->pIndexEntriesBuf = pEntriesBuf;
This->avih.dwSuggestedBufferSize = 0;
for ( i = 0; i < This->cIndexEntries; i++ )
{
if ( This->avih.dwSuggestedBufferSize < This->pIndexEntriesBuf[i].dwChunkLength )
This->avih.dwSuggestedBufferSize = This->pIndexEntriesBuf[i].dwChunkLength;
}
}
else
{
return E_FAIL;
}
if ( This->avih.dwStreams > 100 )
return E_FAIL;
*pcStreams = This->avih.dwStreams;
return NOERROR;
}
static HRESULT CAVIParseImpl_UninitParser( CParserImpl* pImpl )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
ULONG nIndex;
TRACE("(%p)\n",This);
if ( This == NULL )
return NOERROR;
/* destruct */
if ( This->pStreamsBuf != NULL )
{
for ( nIndex = 0; nIndex < This->avih.dwStreams; nIndex++ )
{
/* release this stream */
if ( This->pStreamsBuf[nIndex].pFmtBuf != NULL )
QUARTZ_FreeMem(This->pStreamsBuf[nIndex].pFmtBuf);
}
QUARTZ_FreeMem( This->pStreamsBuf );
This->pStreamsBuf = NULL;
}
if ( This->pIndexEntriesBuf != NULL )
{
QUARTZ_FreeMem( This->pIndexEntriesBuf );
This->pIndexEntriesBuf = NULL;
}
QUARTZ_FreeMem( This );
pImpl->m_pUserData = NULL;
return NOERROR;
}
static LPCWSTR CAVIParseImpl_GetOutPinName( CParserImpl* pImpl, ULONG nStreamIndex )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
int wlen;
TRACE("(%p,%lu)\n",This,nStreamIndex);
if ( This == NULL || nStreamIndex >= This->avih.dwStreams )
return NULL;
wlen = lstrlenW(QUARTZ_AVIParserOutPin_Basename);
memcpy( This->wchWork, QUARTZ_AVIParserOutPin_Basename, sizeof(WCHAR)*wlen );
This->wchWork[ wlen ] = (nStreamIndex/10) + '0';
This->wchWork[ wlen+1 ] = (nStreamIndex%10) + '0';
This->wchWork[ wlen+2 ] = 0;
return This->wchWork;
}
static HRESULT CAVIParseImpl_GetStreamType( CParserImpl* pImpl, ULONG nStreamIndex, AM_MEDIA_TYPE* pmt )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
VIDEOINFOHEADER* pvi;
BITMAPINFOHEADER* pbi;
WAVEFORMATEX* pwfx;
DWORD cbFmt;
DWORD cb;
HRESULT hr;
TRACE("(%p,%lu,%p)\n",This,nStreamIndex,pmt);
if ( This == NULL )
return E_UNEXPECTED;
if ( nStreamIndex >= This->avih.dwStreams )
return E_INVALIDARG;
cbFmt = This->pStreamsBuf[nStreamIndex].cbFmt;
ZeroMemory( pmt, sizeof(AM_MEDIA_TYPE) );
switch ( This->pStreamsBuf[nStreamIndex].strh.fccType )
{
case PARSER_vids:
pbi = (BITMAPINFOHEADER*)This->pStreamsBuf[nStreamIndex].pFmtBuf;
if ( pbi == NULL || cbFmt < sizeof(BITMAPINFOHEADER) )
goto unknown_format;
memcpy( &pmt->majortype, &MEDIATYPE_Video, sizeof(GUID) );
hr = QUARTZ_MediaSubType_FromBitmap( &pmt->subtype, pbi );
if ( FAILED(hr) )
goto unknown_format;
if ( hr != S_OK )
QUARTZ_MediaSubType_FromFourCC( &pmt->subtype, (DWORD)pbi->biCompression );
pmt->bFixedSizeSamples = QUARTZ_BitmapHasFixedSample( pbi ) ? 1 : 0;
pmt->bTemporalCompression = 0; /* FIXME - 1 if inter-frame compression is used */
pmt->lSampleSize = ( pbi->biCompression == 0 ) ? DIBSIZE(*pbi) : pbi->biSizeImage;
memcpy( &pmt->formattype, &FORMAT_VideoInfo, sizeof(GUID) );
cb = sizeof(VIDEOINFOHEADER) + cbFmt;
pmt->pbFormat = (BYTE*)CoTaskMemAlloc( cb );
if ( pmt->pbFormat == NULL )
return E_OUTOFMEMORY;
ZeroMemory( pmt->pbFormat, cb );
pvi = (VIDEOINFOHEADER*)pmt->pbFormat;
pmt->cbFormat = cb;
memcpy( &pvi->bmiHeader, pbi, cbFmt );
break;
case PARSER_auds:
pwfx = (WAVEFORMATEX*)This->pStreamsBuf[nStreamIndex].pFmtBuf;
if ( pwfx == NULL || cbFmt < (sizeof(WAVEFORMATEX)-2) )
goto unknown_format;
memcpy( &pmt->majortype, &MEDIATYPE_Audio, sizeof(GUID) );
QUARTZ_MediaSubType_FromFourCC( &pmt->subtype, (DWORD)pwfx->wFormatTag );
pmt->bFixedSizeSamples = 1;
pmt->bTemporalCompression = 0;
pmt->lSampleSize = pwfx->nBlockAlign;
memcpy( &pmt->formattype, &FORMAT_WaveFormatEx, sizeof(GUID) );
pmt->pUnk = NULL;
cb = ( cbFmt < sizeof(WAVEFORMATEX) ) ? sizeof(WAVEFORMATEX) : cbFmt;
pmt->pbFormat = (BYTE*)CoTaskMemAlloc( cb );
if ( pmt->pbFormat == NULL )
return E_OUTOFMEMORY;
ZeroMemory( pmt->pbFormat, cb );
pmt->cbFormat = cbFmt;
memcpy( pmt->pbFormat, pwfx, cbFmt );
break;
case PARSER_mids:
/* FIXME? */
memcpy( &pmt->majortype, &MEDIATYPE_Midi, sizeof(GUID) );
memcpy( &pmt->subtype, &MEDIASUBTYPE_NULL, sizeof(GUID) );
pmt->bFixedSizeSamples = 0;
pmt->bTemporalCompression = 0;
pmt->lSampleSize = 1;
memcpy( &pmt->formattype, &FORMAT_None, sizeof(GUID) );
pmt->pUnk = NULL;
pmt->cbFormat = 0;
pmt->pbFormat = NULL;
break;
case PARSER_txts:
/* FIXME? */
memcpy( &pmt->majortype, &MEDIATYPE_Text, sizeof(GUID) );
memcpy( &pmt->subtype, &MEDIASUBTYPE_NULL, sizeof(GUID) );
pmt->bFixedSizeSamples = 0;
pmt->bTemporalCompression = 0;
pmt->lSampleSize = 1;
memcpy( &pmt->formattype, &FORMAT_None, sizeof(GUID) );
pmt->pUnk = NULL;
pmt->cbFormat = 0;
pmt->pbFormat = NULL;
break;
default:
goto unknown_format;
}
return NOERROR;
unknown_format:;
FIXME( "(%p) unsupported stream type %c%c%c%c\n",This,
(int)((This->pStreamsBuf[nStreamIndex].strh.fccType>> 0)&0xff),
(int)((This->pStreamsBuf[nStreamIndex].strh.fccType>> 8)&0xff),
(int)((This->pStreamsBuf[nStreamIndex].strh.fccType>>16)&0xff),
(int)((This->pStreamsBuf[nStreamIndex].strh.fccType>>24)&0xff) );
memcpy( &pmt->majortype, &MEDIATYPE_NULL, sizeof(GUID) );
memcpy( &pmt->subtype, &MEDIASUBTYPE_NULL, sizeof(GUID) );
pmt->bFixedSizeSamples = 0;
pmt->bTemporalCompression = 0;
pmt->lSampleSize = 1;
memcpy( &pmt->formattype, &FORMAT_None, sizeof(GUID) );
pmt->pUnk = NULL;
pmt->cbFormat = 0;
pmt->pbFormat = NULL;
return NOERROR;
}
static HRESULT CAVIParseImpl_CheckStreamType( CParserImpl* pImpl, ULONG nStreamIndex, const AM_MEDIA_TYPE* pmt )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
HRESULT hr;
AM_MEDIA_TYPE mt;
VIDEOINFOHEADER* pvi;
VIDEOINFOHEADER* pviCheck;
WAVEFORMATEX* pwfx;
WAVEFORMATEX* pwfxCheck;
TRACE("(%p,%lu,%p)\n",This,nStreamIndex,pmt);
hr = CAVIParseImpl_GetStreamType( pImpl, nStreamIndex, &mt );
if ( FAILED(hr) )
return hr;
TRACE("check GUIDs - %s,%s\n",debugstr_guid(&pmt->majortype),debugstr_guid(&pmt->subtype));
if ( !IsEqualGUID( &pmt->majortype, &mt.majortype ) ||
!IsEqualGUID( &pmt->subtype, &mt.subtype ) ||
!IsEqualGUID( &pmt->formattype, &mt.formattype ) )
{
hr = E_FAIL;
goto end;
}
TRACE("check format\n");
hr = S_OK;
switch ( This->pStreamsBuf[nStreamIndex].strh.fccType )
{
case PARSER_vids:
TRACE("check vids\n");
pvi = (VIDEOINFOHEADER*)mt.pbFormat;
pviCheck = (VIDEOINFOHEADER*)pmt->pbFormat;
if ( pvi == NULL || pviCheck == NULL || pmt->cbFormat < sizeof(VIDEOINFOHEADER) )
hr = E_FAIL;
if ( pvi->bmiHeader.biWidth != pviCheck->bmiHeader.biWidth ||
pvi->bmiHeader.biHeight != pviCheck->bmiHeader.biHeight ||
pvi->bmiHeader.biPlanes != pviCheck->bmiHeader.biPlanes ||
pvi->bmiHeader.biBitCount != pviCheck->bmiHeader.biBitCount ||
pvi->bmiHeader.biCompression != pviCheck->bmiHeader.biCompression ||
pvi->bmiHeader.biClrUsed != pviCheck->bmiHeader.biClrUsed )
hr = E_FAIL;
break;
case PARSER_auds:
TRACE("check auds\n");
pwfx = (WAVEFORMATEX*)mt.pbFormat;
pwfxCheck = (WAVEFORMATEX*)pmt->pbFormat;
if ( pwfx == NULL || pwfxCheck == NULL || pmt->cbFormat < (sizeof(WAVEFORMATEX)-2) )
hr = E_FAIL;
if ( pwfx->wFormatTag != pwfxCheck->wFormatTag ||
pwfx->nBlockAlign != pwfxCheck->nBlockAlign ||
pwfx->wBitsPerSample != pwfxCheck->wBitsPerSample ||
pwfx->nChannels != pwfxCheck->nChannels ||
pwfx->nSamplesPerSec != pwfxCheck->nSamplesPerSec )
hr = E_FAIL;
break;
case PARSER_mids:
case PARSER_txts:
break;
default:
break;
}
end:
QUARTZ_MediaType_Free( &mt );
TRACE("%08lx\n",hr);
return hr;
}
static HRESULT CAVIParseImpl_GetAllocProp( CParserImpl* pImpl, ALLOCATOR_PROPERTIES* pReqProp )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
TRACE("(%p,%p)\n",This,pReqProp);
if ( This == NULL )
return E_UNEXPECTED;
ZeroMemory( pReqProp, sizeof(ALLOCATOR_PROPERTIES) );
pReqProp->cBuffers = This->avih.dwStreams;
pReqProp->cbBuffer = This->avih.dwSuggestedBufferSize;
return NOERROR;
}
static HRESULT CAVIParseImpl_GetNextRequest( CParserImpl* pImpl, ULONG* pnStreamIndex, LONGLONG* pllStart, LONG* plLength, REFERENCE_TIME* prtStart, REFERENCE_TIME* prtStop, DWORD* pdwSampleFlags )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
REFERENCE_TIME rtNext;
DWORD nIndexNext;
DWORD nIndex;
CAVIParseStream* pStream;
const WAVEFORMATEX* pwfx;
TRACE("(%p)\n",This);
if ( This == NULL )
return E_UNEXPECTED;
*pdwSampleFlags = AM_SAMPLE_SPLICEPOINT;
nIndexNext = This->avih.dwStreams;
rtNext = ((REFERENCE_TIME)0x7fffffff<<32)|((REFERENCE_TIME)0xffffffff);
for ( nIndex = 0; nIndex < This->avih.dwStreams; nIndex++ )
{
TRACE("stream %lu - %lu,%lu\n",nIndex,(unsigned long)(This->pStreamsBuf[nIndex].rtCur*1000/QUARTZ_TIMEUNITS),This->pStreamsBuf[nIndex].cIndexCur);
if ( rtNext > This->pStreamsBuf[nIndex].rtCur &&
This->pStreamsBuf[nIndex].cIndexCur < This->pStreamsBuf[nIndex].cIndexEntries )
{
nIndexNext = nIndex;
rtNext = This->pStreamsBuf[nIndex].rtCur;
}
}
if ( nIndexNext >= This->avih.dwStreams )
return S_FALSE;
if ( This->pIndexEntriesBuf != NULL )
{
pStream = &This->pStreamsBuf[nIndexNext];
*pnStreamIndex = nIndexNext;
*pllStart = (LONGLONG)pStream->pIndexEntries[pStream->cIndexCur].dwChunkOffset + 8;
*plLength = (LONG)pStream->pIndexEntries[pStream->cIndexCur].dwChunkLength;
*prtStart = rtNext;
*prtStop = rtNext;
/* FIXME - is this frame keyframe?? */
*pdwSampleFlags = AM_SAMPLE_SPLICEPOINT;
if ( pStream->bDataDiscontinuity )
{
*pdwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
pStream->bDataDiscontinuity = FALSE;
}
switch ( pStream->strh.fccType )
{
case PARSER_vids:
TRACE("vids\n");
pStream->rtInternal ++;
rtNext = pStream->rtInternal * (REFERENCE_TIME)QUARTZ_TIMEUNITS * (REFERENCE_TIME)pStream->strh.dwScale / (REFERENCE_TIME)pStream->strh.dwRate;
/* FIXME - handle AVIPALCHANGE */
break;
case PARSER_auds:
TRACE("auds\n");
pwfx = (const WAVEFORMATEX*)pStream->pFmtBuf;
if ( pwfx != NULL && pStream->cbFmt >= (sizeof(WAVEFORMATEX)-2) )
{
pStream->rtInternal += (REFERENCE_TIME)*plLength;
rtNext = pStream->rtInternal * (REFERENCE_TIME)QUARTZ_TIMEUNITS / (REFERENCE_TIME)pwfx->nAvgBytesPerSec;
}
else
{
pStream->rtInternal += (REFERENCE_TIME)(*plLength);
rtNext = pStream->rtInternal * (REFERENCE_TIME)QUARTZ_TIMEUNITS * (REFERENCE_TIME)pStream->strh.dwScale / ((REFERENCE_TIME)pStream->strh.dwSampleSize * (REFERENCE_TIME)pStream->strh.dwRate);
}
break;
case PARSER_mids:
case PARSER_txts:
default:
pStream->rtInternal += (REFERENCE_TIME)(*plLength);
rtNext = pStream->rtInternal * (REFERENCE_TIME)QUARTZ_TIMEUNITS * (REFERENCE_TIME)pStream->strh.dwScale / ((REFERENCE_TIME)pStream->strh.dwSampleSize * (REFERENCE_TIME)pStream->strh.dwRate);
break;
}
pStream->cIndexCur ++;
pStream->rtCur = rtNext;
*prtStop = rtNext;
}
else
{
ERR( "no idx1\n" );
return E_NOTIMPL;
}
TRACE("return %lu / %ld-%ld / %lu-%lu\n",
*pnStreamIndex,(long)*pllStart,*plLength,
(unsigned long)((*prtStart)*1000/QUARTZ_TIMEUNITS),
(unsigned long)((*prtStop)*1000/QUARTZ_TIMEUNITS));
return NOERROR;
}
static HRESULT CAVIParseImpl_ProcessSample( CParserImpl* pImpl, ULONG nStreamIndex, LONGLONG llStart, LONG lLength, IMediaSample* pSample )
{
CAVIParseImpl* This = (CAVIParseImpl*)pImpl->m_pUserData;
TRACE("(%p,%lu,%ld,%ld,%p)\n",This,nStreamIndex,(long)llStart,lLength,pSample);
if ( This == NULL )
return E_UNEXPECTED;
return NOERROR;
}
static const struct ParserHandlers CAVIParseImpl_Handlers =
{
CAVIParseImpl_InitParser,
CAVIParseImpl_UninitParser,
CAVIParseImpl_GetOutPinName,
CAVIParseImpl_GetStreamType,
CAVIParseImpl_CheckStreamType,
CAVIParseImpl_GetAllocProp,
CAVIParseImpl_GetNextRequest,
CAVIParseImpl_ProcessSample,
/* for IQualityControl */
NULL, /* pQualityNotify */
/* for seeking */
NULL, /* pGetSeekingCaps */
NULL, /* pIsTimeFormatSupported */
NULL, /* pGetCurPos */
NULL, /* pSetCurPos */
NULL, /* pGetDuration */
NULL, /* pGetStopPos */
NULL, /* pSetStopPos */
NULL, /* pGetPreroll */
};
HRESULT QUARTZ_CreateAVISplitter(IUnknown* punkOuter,void** ppobj)
{
return QUARTZ_CreateParser(
punkOuter,ppobj,
&CLSID_AviSplitter,
QUARTZ_AVIParser_Name,
QUARTZ_AVIParserInPin_Name,
&CAVIParseImpl_Handlers );
}
Reference in New Issue View Git Blame Copy Permalink