678 lines
16 KiB
C
678 lines
16 KiB
C
/*
|
|
* Implements IMediaSample2 for CMemMediaSample.
|
|
*
|
|
* 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 "winerror.h"
|
|
#include "strmif.h"
|
|
#include "vfwmsgs.h"
|
|
|
|
#include "wine/debug.h"
|
|
WINE_DEFAULT_DEBUG_CHANNEL(quartz);
|
|
|
|
#include "quartz_private.h"
|
|
#include "sample.h"
|
|
#include "mtype.h"
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Helper functions
|
|
*
|
|
*/
|
|
|
|
HRESULT QUARTZ_IMediaSample_GetProperties(
|
|
IMediaSample* pSample,
|
|
AM_SAMPLE2_PROPERTIES* pProp )
|
|
{
|
|
#if 0 /* not yet */
|
|
HRESULT hr;
|
|
AM_SAMPLE2_PROPERTIES prop;
|
|
IMediaSample2* pSample2 = NULL;
|
|
|
|
ZeroMemory( &prop, sizeof(AM_SAMPLE2_PROPERTIES) );
|
|
|
|
hr = IMediaSample_QueryInterface( pSample, &IID_IMediaSample2, (void**)&pSample2 );
|
|
if ( hr == S_OK )
|
|
{
|
|
hr = IMediaSample2_GetProperties(pSample2,sizeof(AM_SAMPLE2_PROPERTIES),&prop);
|
|
IMediaSample2_Release(pSample2);
|
|
if ( hr == S_OK )
|
|
{
|
|
memcpy( pProp, &prop, sizeof(AM_SAMPLE2_PROPERTIES) );
|
|
pProp->pMediaType =
|
|
QUARTZ_MediaType_Duplicate( &prop.pMediaType );
|
|
|
|
return NOERROR;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
pProp->cbData = sizeof(AM_SAMPLE2_PROPERTIES);
|
|
pProp->dwTypeSpecificFlags = 0;
|
|
pProp->dwSampleFlags = 0;
|
|
if ( IMediaSample_IsSyncPoint(pSample) == S_OK )
|
|
pProp->dwSampleFlags |= AM_SAMPLE_SPLICEPOINT;
|
|
if ( IMediaSample_IsPreroll(pSample) == S_OK )
|
|
pProp->dwSampleFlags |= AM_SAMPLE_PREROLL;
|
|
if ( IMediaSample_IsDiscontinuity(pSample) == S_OK )
|
|
pProp->dwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
|
|
pProp->lActual = (LONG)IMediaSample_GetActualDataLength(pSample);
|
|
if ( IMediaSample_GetTime(pSample,&pProp->tStart,&pProp->tStop) == S_OK )
|
|
pProp->dwSampleFlags |= AM_SAMPLE_TIMEVALID | AM_SAMPLE_STOPVALID;
|
|
pProp->dwStreamId = 0;
|
|
if ( IMediaSample_GetMediaType(pSample,&(pProp->pMediaType)) == S_OK )
|
|
pProp->dwSampleFlags |= AM_SAMPLE_TYPECHANGED;
|
|
IMediaSample_GetPointer(pSample,&(pProp->pbBuffer));
|
|
pProp->cbBuffer = (LONG)IMediaSample_GetSize(pSample);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT QUARTZ_IMediaSample_SetProperties(
|
|
IMediaSample* pSample,
|
|
const AM_SAMPLE2_PROPERTIES* pProp )
|
|
{
|
|
HRESULT hr;
|
|
AM_SAMPLE2_PROPERTIES prop;
|
|
#if 0 /* not yet */
|
|
IMediaSample2* pSample2 = NULL;
|
|
#endif
|
|
|
|
memcpy( &prop, pProp, sizeof(AM_SAMPLE2_PROPERTIES) );
|
|
prop.cbData = sizeof(AM_SAMPLE2_PROPERTIES);
|
|
prop.pbBuffer = NULL;
|
|
prop.cbBuffer = 0;
|
|
|
|
#if 0 /* not yet */
|
|
hr = IMediaSample_QueryInterface( pSample, &IID_IMediaSample2, (void**)&pSample2 );
|
|
if ( hr == S_OK )
|
|
{
|
|
hr = IMediaSample2_SetProperties(pSample2,sizeof(AM_SAMPLE2_PROPERTIES),&prop);
|
|
IMediaSample2_Release(pSample2);
|
|
if ( hr == S_OK )
|
|
return NOERROR;
|
|
}
|
|
#endif
|
|
|
|
hr = S_OK;
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
hr = IMediaSample_SetSyncPoint(pSample,
|
|
(prop.dwSampleFlags & AM_SAMPLE_SPLICEPOINT) ? TRUE : FALSE);
|
|
if ( SUCCEEDED(hr) )
|
|
hr = IMediaSample_SetPreroll(pSample,
|
|
(prop.dwSampleFlags & AM_SAMPLE_PREROLL) ? TRUE : FALSE);
|
|
if ( SUCCEEDED(hr) )
|
|
hr = IMediaSample_SetDiscontinuity(pSample,
|
|
(prop.dwSampleFlags & AM_SAMPLE_DATADISCONTINUITY) ? TRUE : FALSE);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
TRACE("length = %ld/%ld\n",prop.lActual,pProp->cbBuffer);
|
|
hr = IMediaSample_SetActualDataLength(pSample,prop.lActual);
|
|
}
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( ( prop.dwSampleFlags & AM_SAMPLE_TIMEVALID) &&
|
|
( prop.dwSampleFlags & AM_SAMPLE_STOPVALID) )
|
|
hr = IMediaSample_SetTime(pSample,&prop.tStart,&prop.tStop);
|
|
else
|
|
hr = IMediaSample_SetTime(pSample,NULL,NULL);
|
|
}
|
|
if ( SUCCEEDED(hr) )
|
|
hr = IMediaSample_SetMediaType(pSample,
|
|
(prop.dwSampleFlags & AM_SAMPLE_TYPECHANGED) ?
|
|
prop.pMediaType : NULL);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT QUARTZ_IMediaSample_Copy(
|
|
IMediaSample* pDstSample,
|
|
IMediaSample* pSrcSample,
|
|
BOOL bCopyData )
|
|
{
|
|
HRESULT hr;
|
|
AM_SAMPLE2_PROPERTIES prop;
|
|
BYTE* pDataSrc = NULL;
|
|
BYTE* pDataDst = NULL;
|
|
|
|
hr = QUARTZ_IMediaSample_GetProperties( pSrcSample, &prop );
|
|
if ( FAILED(hr) )
|
|
return hr;
|
|
if ( !bCopyData )
|
|
prop.lActual = 0;
|
|
hr = QUARTZ_IMediaSample_SetProperties( pDstSample, &prop );
|
|
if ( prop.pMediaType != NULL )
|
|
QUARTZ_MediaType_Destroy( prop.pMediaType );
|
|
|
|
if ( SUCCEEDED(hr) && bCopyData )
|
|
{
|
|
hr = IMediaSample_GetPointer(pSrcSample,&pDataSrc);
|
|
if ( SUCCEEDED(hr) )
|
|
hr = IMediaSample_GetPointer(pDstSample,&pDataDst);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( pDataSrc != NULL && pDataDst != NULL )
|
|
memcpy( pDataDst, pDataSrc, prop.lActual );
|
|
else
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* CMemMediaSample::IMediaSample2
|
|
*
|
|
*/
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnQueryInterface(IMediaSample2* iface,REFIID riid,void** ppobj)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
|
|
|
|
if ( ppobj == NULL )
|
|
return E_POINTER;
|
|
|
|
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
|
|
IsEqualGUID( riid, &IID_IMediaSample ) ||
|
|
IsEqualGUID( riid, &IID_IMediaSample2 ) )
|
|
{
|
|
*ppobj = iface;
|
|
IMediaSample2_AddRef(iface);
|
|
return NOERROR;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
IMediaSample2_fnAddRef(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return InterlockedExchangeAdd(&(This->ref),1) + 1;
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
IMediaSample2_fnRelease(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->ref == 0 )
|
|
{
|
|
ERR("(%p) - released sample!\n",This);
|
|
return 0;
|
|
}
|
|
|
|
ref = InterlockedExchangeAdd(&(This->ref),-1) - 1;
|
|
if ( ref > 0 )
|
|
return (ULONG)ref;
|
|
|
|
/* this class would be reused.. */
|
|
if ( This->prop.pMediaType != NULL )
|
|
{
|
|
QUARTZ_MediaType_Destroy( This->prop.pMediaType );
|
|
This->prop.pMediaType = NULL;
|
|
}
|
|
This->prop.dwTypeSpecificFlags = 0;
|
|
This->prop.dwSampleFlags = 0;
|
|
This->prop.lActual = This->prop.cbBuffer;
|
|
|
|
IMemAllocator_ReleaseBuffer(This->pOwner,(IMediaSample*)iface);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnGetPointer(IMediaSample2* iface,BYTE** ppData)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
if ( This->ref == 0 )
|
|
{
|
|
ERR("(%p) - released sample!\n",This);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if ( ppData == NULL )
|
|
return E_POINTER;
|
|
|
|
*ppData = This->prop.pbBuffer;
|
|
return NOERROR;
|
|
}
|
|
|
|
static long WINAPI
|
|
IMediaSample2_fnGetSize(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return This->prop.cbBuffer;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnGetTime(IMediaSample2* iface,REFERENCE_TIME* prtStart,REFERENCE_TIME* prtEnd)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,prtStart,prtEnd);
|
|
|
|
if ( This->ref == 0 )
|
|
{
|
|
ERR("(%p) - released sample!\n",This);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if ( prtStart == NULL || prtEnd == NULL )
|
|
return E_POINTER;
|
|
|
|
if ( ( This->prop.dwSampleFlags & AM_SAMPLE_TIMEVALID ) &&
|
|
( This->prop.dwSampleFlags & AM_SAMPLE_STOPVALID ) )
|
|
{
|
|
*prtStart = This->prop.tStart;
|
|
*prtEnd = This->prop.tStop;
|
|
return NOERROR;
|
|
}
|
|
|
|
return VFW_E_MEDIA_TIME_NOT_SET;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetTime(IMediaSample2* iface,REFERENCE_TIME* prtStart,REFERENCE_TIME* prtEnd)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%p,%p) stub!\n",This,prtStart,prtEnd);
|
|
|
|
This->prop.dwSampleFlags &= ~(AM_SAMPLE_TIMEVALID|AM_SAMPLE_STOPVALID);
|
|
if ( prtStart != NULL )
|
|
{
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_TIMEVALID;
|
|
This->prop.tStart = *prtStart;
|
|
}
|
|
if ( prtEnd != NULL )
|
|
{
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_STOPVALID;
|
|
This->prop.tStop = *prtEnd;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnIsSyncPoint(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return ( This->prop.dwSampleFlags & AM_SAMPLE_SPLICEPOINT ) ?
|
|
S_OK : S_FALSE;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetSyncPoint(IMediaSample2* iface,BOOL bSync)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%d)\n",This,bSync);
|
|
|
|
if ( bSync )
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_SPLICEPOINT;
|
|
else
|
|
This->prop.dwSampleFlags &= ~AM_SAMPLE_SPLICEPOINT;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnIsPreroll(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return ( This->prop.dwSampleFlags & AM_SAMPLE_PREROLL ) ?
|
|
S_OK : S_FALSE;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetPreroll(IMediaSample2* iface,BOOL bPreroll)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%d)\n",This,bPreroll);
|
|
|
|
if ( bPreroll )
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_PREROLL;
|
|
else
|
|
This->prop.dwSampleFlags &= ~AM_SAMPLE_PREROLL;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static long WINAPI
|
|
IMediaSample2_fnGetActualDataLength(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return This->prop.lActual;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetActualDataLength(IMediaSample2* iface,long lLength)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%ld)\n",This,lLength);
|
|
|
|
if ( This->prop.cbBuffer < lLength )
|
|
return E_INVALIDARG;
|
|
|
|
This->prop.lActual = lLength;
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnGetMediaType(IMediaSample2* iface,AM_MEDIA_TYPE** ppmt)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%p)\n",This,ppmt);
|
|
|
|
if ( ppmt == NULL )
|
|
return E_POINTER;
|
|
*ppmt = NULL;
|
|
if ( !(This->prop.dwSampleFlags & AM_SAMPLE_TYPECHANGED) )
|
|
return S_FALSE;
|
|
|
|
*ppmt = QUARTZ_MediaType_Duplicate( This->prop.pMediaType );
|
|
if ( *ppmt == NULL )
|
|
return E_OUTOFMEMORY;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetMediaType(IMediaSample2* iface,AM_MEDIA_TYPE* pmt)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
AM_MEDIA_TYPE* pmtDup;
|
|
|
|
TRACE("(%p)->(%p)\n",This,pmt);
|
|
|
|
if ( pmt == NULL )
|
|
{
|
|
/* FIXME? */
|
|
if ( This->prop.pMediaType != NULL )
|
|
{
|
|
QUARTZ_MediaType_Destroy( This->prop.pMediaType );
|
|
This->prop.pMediaType = NULL;
|
|
}
|
|
This->prop.dwSampleFlags &= ~AM_SAMPLE_TYPECHANGED;
|
|
return NOERROR;
|
|
}
|
|
|
|
pmtDup = QUARTZ_MediaType_Duplicate( pmt );
|
|
if ( pmtDup == NULL )
|
|
return E_OUTOFMEMORY;
|
|
|
|
if ( This->prop.pMediaType != NULL )
|
|
QUARTZ_MediaType_Destroy( This->prop.pMediaType );
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_TYPECHANGED;
|
|
This->prop.pMediaType = pmtDup;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnIsDiscontinuity(IMediaSample2* iface)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
|
|
return ( This->prop.dwSampleFlags & AM_SAMPLE_DATADISCONTINUITY ) ?
|
|
S_OK : S_FALSE;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetDiscontinuity(IMediaSample2* iface,BOOL bDiscontinuity)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%d)\n",This,bDiscontinuity);
|
|
|
|
if ( bDiscontinuity )
|
|
This->prop.dwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
|
|
else
|
|
This->prop.dwSampleFlags &= ~AM_SAMPLE_DATADISCONTINUITY;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnGetMediaTime(IMediaSample2* iface,LONGLONG* pTimeStart,LONGLONG* pTimeEnd)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%p,%p)\n",This,pTimeStart,pTimeEnd);
|
|
|
|
if ( pTimeStart == NULL || pTimeEnd == NULL )
|
|
return E_POINTER;
|
|
|
|
if ( !This->fMediaTimeIsValid )
|
|
return VFW_E_MEDIA_TIME_NOT_SET;
|
|
|
|
*pTimeStart = This->llMediaTimeStart;
|
|
*pTimeEnd = This->llMediaTimeEnd;
|
|
|
|
return NOERROR;
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetMediaTime(IMediaSample2* iface,LONGLONG* pTimeStart,LONGLONG* pTimeEnd)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->()\n",This);
|
|
if ( pTimeStart == NULL || pTimeEnd == NULL )
|
|
{
|
|
This->fMediaTimeIsValid = FALSE;
|
|
}
|
|
else
|
|
{
|
|
This->fMediaTimeIsValid = TRUE;
|
|
This->llMediaTimeStart = *pTimeStart;
|
|
This->llMediaTimeEnd = *pTimeEnd;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnGetProperties(IMediaSample2* iface,DWORD cbProp,BYTE* pbProp)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
|
|
TRACE("(%p)->(%lu,%p)\n",This,cbProp,pbProp);
|
|
|
|
if ( cbProp < 0 || cbProp > sizeof(AM_SAMPLE2_PROPERTIES) )
|
|
return E_FAIL;
|
|
memcpy( pbProp, &This->prop, cbProp );
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
IMediaSample2_fnSetProperties(IMediaSample2* iface,DWORD cbProp,const BYTE* pbProp)
|
|
{
|
|
ICOM_THIS(CMemMediaSample,iface);
|
|
const AM_SAMPLE2_PROPERTIES* pProp;
|
|
AM_SAMPLE2_PROPERTIES propNew;
|
|
AM_MEDIA_TYPE* pmtDup = NULL;
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
TRACE("(%p)->(%lu,%p)\n",This,cbProp,pbProp);
|
|
|
|
if ( pbProp == NULL )
|
|
return E_POINTER;
|
|
pProp = (const AM_SAMPLE2_PROPERTIES*)pbProp;
|
|
if ( cbProp != sizeof(AM_SAMPLE2_PROPERTIES) )
|
|
goto err;
|
|
|
|
CopyMemory( &propNew, pProp, sizeof(AM_SAMPLE2_PROPERTIES) );
|
|
if ( propNew.cbData != sizeof(AM_SAMPLE2_PROPERTIES) )
|
|
goto err;
|
|
|
|
if ( This->prop.cbBuffer < propNew.lActual )
|
|
goto err;
|
|
|
|
if ( propNew.dwSampleFlags & AM_SAMPLE_TYPECHANGED )
|
|
{
|
|
pmtDup = QUARTZ_MediaType_Duplicate( propNew.pMediaType );
|
|
if ( pmtDup == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if ( propNew.pbBuffer != NULL && propNew.pbBuffer != This->prop.pbBuffer )
|
|
goto err;
|
|
if ( propNew.cbBuffer != 0 && propNew.cbBuffer != This->prop.cbBuffer )
|
|
goto err;
|
|
|
|
if ( This->prop.pMediaType != NULL )
|
|
QUARTZ_MediaType_Destroy( This->prop.pMediaType );
|
|
CopyMemory( &This->prop, &propNew, sizeof(AM_SAMPLE2_PROPERTIES) );
|
|
This->prop.pMediaType = pmtDup;
|
|
pmtDup = NULL;
|
|
|
|
hr= NOERROR;
|
|
err:
|
|
if ( pmtDup != NULL )
|
|
QUARTZ_MediaType_Destroy( pmtDup );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
static ICOM_VTABLE(IMediaSample2) imediasample2 =
|
|
{
|
|
ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
|
|
/* IUnknown fields */
|
|
IMediaSample2_fnQueryInterface,
|
|
IMediaSample2_fnAddRef,
|
|
IMediaSample2_fnRelease,
|
|
/* IMediaSample fields */
|
|
IMediaSample2_fnGetPointer,
|
|
IMediaSample2_fnGetSize,
|
|
IMediaSample2_fnGetTime,
|
|
IMediaSample2_fnSetTime,
|
|
IMediaSample2_fnIsSyncPoint,
|
|
IMediaSample2_fnSetSyncPoint,
|
|
IMediaSample2_fnIsPreroll,
|
|
IMediaSample2_fnSetPreroll,
|
|
IMediaSample2_fnGetActualDataLength,
|
|
IMediaSample2_fnSetActualDataLength,
|
|
IMediaSample2_fnGetMediaType,
|
|
IMediaSample2_fnSetMediaType,
|
|
IMediaSample2_fnIsDiscontinuity,
|
|
IMediaSample2_fnSetDiscontinuity,
|
|
IMediaSample2_fnGetMediaTime,
|
|
IMediaSample2_fnSetMediaTime,
|
|
/* IMediaSample2 fields */
|
|
IMediaSample2_fnGetProperties,
|
|
IMediaSample2_fnSetProperties,
|
|
};
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* new/delete for CMemMediaSample
|
|
*
|
|
*/
|
|
|
|
HRESULT QUARTZ_CreateMemMediaSample(
|
|
BYTE* pbData, DWORD dwDataLength,
|
|
IMemAllocator* pOwner,
|
|
CMemMediaSample** ppSample )
|
|
{
|
|
CMemMediaSample* pms;
|
|
|
|
TRACE("(%p,%08lx,%p,%p)\n",pbData,dwDataLength,pOwner,ppSample);
|
|
pms = (CMemMediaSample*)QUARTZ_AllocObj( sizeof(CMemMediaSample) );
|
|
if ( pms == NULL )
|
|
return E_OUTOFMEMORY;
|
|
|
|
ICOM_VTBL(pms) = &imediasample2;
|
|
pms->ref = 0;
|
|
pms->pOwner = pOwner;
|
|
pms->fMediaTimeIsValid = FALSE;
|
|
pms->llMediaTimeStart = 0;
|
|
pms->llMediaTimeEnd = 0;
|
|
ZeroMemory( &(pms->prop), sizeof(pms->prop) );
|
|
pms->prop.cbData = sizeof(pms->prop);
|
|
pms->prop.dwTypeSpecificFlags = 0;
|
|
pms->prop.dwSampleFlags = 0;
|
|
pms->prop.pbBuffer = pbData;
|
|
pms->prop.cbBuffer = (LONG)dwDataLength;
|
|
pms->prop.lActual = (LONG)dwDataLength;
|
|
|
|
*ppSample = pms;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
void QUARTZ_DestroyMemMediaSample(
|
|
CMemMediaSample* pSample )
|
|
{
|
|
TRACE("(%p)\n",pSample);
|
|
|
|
QUARTZ_FreeObj( pSample );
|
|
}
|
|
|