reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-24 12:20:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added WAVE parser.

Browse Source
This commit is contained in:
Christian Costa 2005-02-10 17:13:18 +00:00 committed by Alexandre Julliard
parent 1510cce8fa
commit 80a2e6e93b
6 changed files with 337 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dlls/quartz/Makefile.in
View File

@ -27,7 +27,8 @@ C_SRCS = \
regsvr.c \
systemclock.c \
transform.c \
videorenderer.c
videorenderer.c \
waveparser.c
RC_SRCS = version.rc

3
dlls/quartz/main.c
View File

@ -70,7 +70,8 @@ static const struct object_creation_info object_creation[] =
{ &CLSID_DSoundRender, DSoundRender_create },
{ &CLSID_AVIDec, AVIDec_create },
{ &CLSID_SystemClock, &QUARTZ_CreateSystemClock },
{ &CLSID_ACMWrapper, &ACMWrapper_create }
{ &CLSID_ACMWrapper, &ACMWrapper_create },
{ &CLSID_WAVEParser, &WAVEParser_create }
};
static HRESULT WINAPI

1
dlls/quartz/quartz_private.h
View File

@ -51,6 +51,7 @@ HRESULT DSoundRender_create(IUnknown * pUnkOuter, LPVOID * ppv);
HRESULT VideoRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv);
HRESULT QUARTZ_CreateSystemClock(IUnknown * pUnkOuter, LPVOID * ppv);
HRESULT ACMWrapper_create(IUnknown * pUnkOuter, LPVOID * ppv);
HRESULT WAVEParser_create(IUnknown * pUnkOuter, LPVOID * ppv);
HRESULT EnumMonikerImpl_Create(IMoniker ** ppMoniker, ULONG nMonikerCount, IEnumMoniker ** ppEnum);

25
dlls/quartz/regsvr.c
View File

@ -916,6 +916,12 @@ static struct regsvr_coclass const coclass_list[] = {
"quartz.dll",
"Both"
},
{ &CLSID_WAVEParser,
"Wave Parser",
NULL,
"quartz.dll",
"Both"
},
{ NULL } /* list terminator */
};
@ -1087,6 +1093,25 @@ static struct regsvr_filter const filter_list[] = {
{ 0xFFFFFFFF },
}
},
{ &CLSID_WAVEParser,
&CLSID_LegacyAmFilterCategory,
{'W','a','v','e',' ','P','a','r','s','e','r',0},
0x400000,
{ { 0,
{ { &MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE },
{ &MEDIATYPE_Stream, &MEDIASUBTYPE_AU },
{ &MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF },
{ NULL }
},
},
{ REG_PINFLAG_B_OUTPUT,
{ { &MEDIATYPE_Audio, &GUID_NULL },
{ NULL }
},
},
{ 0xFFFFFFFF },
}
},
{ NULL } /* list terminator */
};

306
dlls/quartz/waveparser.c Normal file
View File

@ -0,0 +1,306 @@
/*
* WAVE Parser Filter
*
* Copyright 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
*/
#include "quartz_private.h"
#include "control_private.h"
#include "pin.h"
#include "uuids.h"
#include "aviriff.h"
#include "mmreg.h"
#include "vfwmsgs.h"
#include "mmsystem.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);
static const WCHAR wcsOutputPinName[] = {'o','u','t','p','u','t',' ','p','i','n',0};
typedef struct WAVEParserImpl
{
ParserImpl Parser;
IMediaSample * pCurrentSample;
LONGLONG StartOfFile; /* in media time */
LONGLONG EndOfFile;
} WAVEParserImpl;
static HRESULT WAVEParser_Sample(LPVOID iface, IMediaSample * pSample)
{
WAVEParserImpl *This = (WAVEParserImpl *)iface;
LPBYTE pbSrcStream = NULL;
long cbSrcStream = 0;
REFERENCE_TIME tStart, tStop;
HRESULT hr;
BOOL bMoreData = TRUE;
Parser_OutputPin * pOutputPin;
BYTE * pbDstStream;
long cbDstStream;
long chunk_remaining_bytes = 0;
long offset_src = 0;
hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
cbSrcStream = IMediaSample_GetActualDataLength(pSample);
assert(BYTES_FROM_MEDIATIME(tStop - tStart) == cbSrcStream);
pOutputPin = (Parser_OutputPin *)This->Parser.ppPins[1];
if (tStop < This->StartOfFile)
return S_OK;
if (tStart < This->StartOfFile)
offset_src = BYTES_FROM_MEDIATIME(This->StartOfFile - tStart);
while (bMoreData)
{
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 due to error (%lx)\n", hr);
This->pCurrentSample = NULL;
return hr;
}
}
hr = IMediaSample_GetPointer(This->pCurrentSample, &pbDstStream);
if (SUCCEEDED(hr))
{
cbDstStream = IMediaSample_GetSize(This->pCurrentSample);
chunk_remaining_bytes = cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample);
assert(chunk_remaining_bytes >= 0);
assert(chunk_remaining_bytes <= cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample));
}
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, TRUE);
}
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;
}
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;
}
offset_src += chunk_remaining_bytes;
}
return hr;
}
static HRESULT WAVEParser_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
{
if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream))
return S_FALSE;
if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_WAVE))
return S_OK;
if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_AU) || IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_AIFF))
FIXME("AU and AIFF files not supported yet!\n");
return S_FALSE;
}
static HRESULT WAVEParser_InputPin_PreConnect(IPin * iface, IPin * pConnectPin)
{
PullPin *This = (PullPin *)iface;
HRESULT hr;
RIFFLIST list;
RIFFCHUNK chunk;
LONGLONG pos = 0; /* in bytes */
PIN_INFO piOutput;
ALLOCATOR_PROPERTIES props;
AM_MEDIA_TYPE amt;
float fSamplesPerSec = 0.0f;
DWORD dwSampleSize = 0;
DWORD dwLength = 0;
WAVEParserImpl * pWAVEParser = (WAVEParserImpl *)This->pin.pinInfo.pFilter;
piOutput.dir = PINDIR_OUTPUT;
piOutput.pFilter = (IBaseFilter *)This;
strncpyW(piOutput.achName, wcsOutputPinName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
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 != mmioFOURCC('W','A','V','E'))
{
ERR("Input stream not an WAVE RIFF file\n");
return E_FAIL;
}
hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
pos += sizeof(chunk);
if (chunk.fcc != mmioFOURCC('f','m','t',' '))
{
ERR("Expected 'fmt ' chunk, but got %.04s\n", (LPSTR)&chunk.fcc);
return E_FAIL;
}
memcpy(&amt.majortype, &MEDIATYPE_Audio, sizeof(GUID));
memcpy(&amt.formattype, &FORMAT_WaveFormatEx, sizeof(GUID));
amt.cbFormat = chunk.cb;
amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
amt.pUnk = NULL;
hr = IAsyncReader_SyncRead(This->pReader, pos, amt.cbFormat, amt.pbFormat);
memcpy(&amt.subtype, &MEDIATYPE_Audio, sizeof(GUID));
amt.subtype.Data1 = ((WAVEFORMATEX*)amt.pbFormat)->wFormatTag;
/* CopyMediaType(&((OutputPin*)pWAVEParser->ppPins[1])->pin.mtCurrent, &amt); */
((Parser_OutputPin*)pWAVEParser->Parser.ppPins[1])->pmt = (AM_MEDIA_TYPE*) CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
CopyMediaType(((Parser_OutputPin*)pWAVEParser->Parser.ppPins[1])->pmt, &amt);
/* Update buffer alignment of media samples in output */
((Parser_OutputPin*)pWAVEParser->Parser.ppPins[1])->pin.allocProps.cbAlign = ((WAVEFORMATEX*)amt.pbFormat)->nBlockAlign;
pos += chunk.cb;
hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
if (chunk.fcc == mmioFOURCC('f','a','c','t'))
{
FIXME("'fact' chunk not supported yet\n");
pos += sizeof(chunk) + chunk.cb;
hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
}
if (chunk.fcc != mmioFOURCC('d','a','t','a'))
{
ERR("Expected 'data' chunk, but got %.04s\n", (LPSTR)&chunk.fcc);
return E_FAIL;
}
if (hr == S_OK)
{
pWAVEParser->StartOfFile = MEDIATIME_FROM_BYTES(pos + sizeof(RIFFCHUNK));
pWAVEParser->EndOfFile = MEDIATIME_FROM_BYTES(pos + chunk.cb + sizeof(RIFFCHUNK));
}
if (hr != S_OK)
return E_FAIL;
props.cbAlign = 1;
props.cbPrefix = 0;
props.cbBuffer = 4096;
props.cBuffers = 2;
hr = Parser_AddPin(&(pWAVEParser->Parser), &piOutput, &props, &amt, fSamplesPerSec, dwSampleSize, dwLength);
TRACE("WAVE File ok\n");
return hr;
}
HRESULT WAVEParser_create(IUnknown * pUnkOuter, LPVOID * ppv)
{
HRESULT hr;
WAVEParserImpl * 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(WAVEParserImpl));
This->pCurrentSample = NULL;
hr = Parser_Create(&(This->Parser), &CLSID_WAVEParser, WAVEParser_Sample, WAVEParser_QueryAccept, WAVEParser_InputPin_PreConnect);
if (FAILED(hr))
return hr;
*ppv = (LPVOID)This;
return hr;
}

1
include/uuids.h
View File

@ -130,6 +130,7 @@ OUR_GUID_ENTRY(CLSID_CaptureProperties, 0x1b544c22, 0xfd0b, 0x11ce,
OUR_GUID_ENTRY(CLSID_FGControl, 0xe436ebb4, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70)
OUR_GUID_ENTRY(CLSID_MOVReader, 0x44584800, 0xf8ee, 0x11ce, 0xb2, 0xd4, 0x00, 0xdd, 0x01, 0x10, 0x1b, 0x85)
OUR_GUID_ENTRY(CLSID_QuickTimeParser, 0xd51bd5a0, 0x7548, 0x11cf, 0xa5, 0x20, 0x00, 0x80, 0xc7, 0x7e, 0xf5, 0x8a)
OUR_GUID_ENTRY(CLSID_WAVEParser, 0xd51bd5a1, 0x7548, 0x11cf, 0xa5, 0x20, 0x00, 0x80, 0xc7, 0x7e, 0xf5, 0x8a)
OUR_GUID_ENTRY(CLSID_QTDec, 0xfdfe9681, 0x74a3, 0x11d0, 0xaf, 0xa7, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42)
OUR_GUID_ENTRY(CLSID_AVIDoc, 0xd3588ab0, 0x0781, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70)
OUR_GUID_ENTRY(CLSID_AVIDocWriter, 0xd3588ab1, 0x0781, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70)