Sweden-Number/dlls/quartz/sample.c

678 lines
16 KiB
C
Raw Normal View History

2001-09-17 22:04:28 +02:00
/*
* 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
2001-09-17 22:04:28 +02:00
*/
#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);
2001-09-17 22:04:28 +02:00
#include "quartz_private.h"
#include "sample.h"
#include "mtype.h"
2001-09-17 22:04:28 +02:00
/***************************************************************************
*
* 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
*
*/
2001-09-17 22:04:28 +02:00
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;
}
2001-09-17 22:04:28 +02:00
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;
2001-09-17 22:04:28 +02:00
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;
}
2001-09-17 22:04:28 +02:00
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;
}
2001-09-17 22:04:28 +02:00
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 )
2001-09-17 22:04:28 +02:00
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;
2001-09-17 22:04:28 +02:00
if ( !(This->prop.dwSampleFlags & AM_SAMPLE_TYPECHANGED) )
return S_FALSE;
*ppmt = QUARTZ_MediaType_Duplicate( This->prop.pMediaType );
if ( *ppmt == NULL )
return E_OUTOFMEMORY;
2001-09-17 22:04:28 +02:00
return NOERROR;
2001-09-17 22:04:28 +02:00
}
static HRESULT WINAPI
IMediaSample2_fnSetMediaType(IMediaSample2* iface,AM_MEDIA_TYPE* pmt)
{
ICOM_THIS(CMemMediaSample,iface);
AM_MEDIA_TYPE* pmtDup;
2001-09-17 22:04:28 +02:00
TRACE("(%p)->(%p)\n",This,pmt);
2001-09-17 22:04:28 +02:00
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;
}
2001-09-17 22:04:28 +02:00
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;
2001-09-17 22:04:28 +02:00
}
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);
2001-09-17 22:04:28 +02:00
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;
2001-09-17 22:04:28 +02:00
TRACE("(%p)->(%lu,%p)\n",This,cbProp,pbProp);
2001-09-17 22:04:28 +02:00
if ( pbProp == NULL )
return E_POINTER;
pProp = (const AM_SAMPLE2_PROPERTIES*)pbProp;
if ( cbProp != sizeof(AM_SAMPLE2_PROPERTIES) )
goto err;
2001-09-17 22:04:28 +02:00
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;
}
2001-09-17 22:04:28 +02:00
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
*
*/
2001-09-17 22:04:28 +02:00
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;
2001-09-17 22:04:28 +02:00
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 )
{
2001-10-01 22:53:58 +02:00
TRACE("(%p)\n",pSample);
2001-09-17 22:04:28 +02:00
QUARTZ_FreeObj( pSample );
}