dlls/quartz/waveparser.c

   1 /*
   2  * WAVE Parser Filter
   3  *
   4  * Copyright 2005 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22 #include "control_private.h"
  23 #include "pin.h"
  24
  25 #include "uuids.h"
  26 #include "aviriff.h"
  27 #include "mmreg.h"
  28 #include "vfwmsgs.h"
  29 #include "mmsystem.h"
  30
  31 #include "fourcc.h"
  32
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 #include <math.h>
  37 #include <assert.h>
  38
  39 #include "parser.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  42
  43 static const WCHAR wcsOutputPinName[] = {'o','u','t','p','u','t',' ','p','i','n',0};
  44
  45 typedef struct WAVEParserImpl
  46 {
  47     ParserImpl Parser;
  48     IMediaSample * pCurrentSample;
  49     LONGLONG StartOfFile; /* in media time */
  50     LONGLONG EndOfFile;
  51 } WAVEParserImpl;
  52
  53 static HRESULT WAVEParser_Sample(LPVOID iface, IMediaSample * pSample)
  54 {
  55     WAVEParserImpl *This = (WAVEParserImpl *)iface;
  56     LPBYTE pbSrcStream = NULL;
  57     long cbSrcStream = 0;
  58     REFERENCE_TIME tStart, tStop;
  59     HRESULT hr;
  60     BOOL bMoreData = TRUE;
  61     Parser_OutputPin * pOutputPin;
  62     BYTE * pbDstStream;
  63     long cbDstStream;
  64     long chunk_remaining_bytes = 0;
  65     long offset_src = 0;
  66
  67     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
  68
  69     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
  70
  71     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
  72
  73     assert(BYTES_FROM_MEDIATIME(tStop - tStart) == cbSrcStream);
  74
  75     pOutputPin = (Parser_OutputPin *)This->Parser.ppPins[1];
  76
  77     if (tStop < This->StartOfFile)
  78         return S_OK;
  79
  80     if (tStart < This->StartOfFile)
  81         offset_src = BYTES_FROM_MEDIATIME(This->StartOfFile - tStart);
  82
  83     while (bMoreData)
  84     {
  85         if (!This->pCurrentSample)
  86         {
  87             /* cache media sample until it is ready to be despatched
  88              * (i.e. we reach the end of the chunk) */
  89             hr = OutputPin_GetDeliveryBuffer(&pOutputPin->pin, &This->pCurrentSample, NULL, NULL, 0);
  90
  91             if (SUCCEEDED(hr))
  92             {
  93                 hr = IMediaSample_SetActualDataLength(This->pCurrentSample, 0);
  94                 assert(hr == S_OK);
  95             }
  96             else
  97             {
  98                 TRACE("Skipping sending sample due to error (%x)\n", hr);
  99                 This->pCurrentSample = NULL;
 100                 break;
 101             }
 102         }
 103
 104         hr = IMediaSample_GetPointer(This->pCurrentSample, &pbDstStream);
 105
 106         if (SUCCEEDED(hr))
 107         {
 108             cbDstStream = IMediaSample_GetSize(This->pCurrentSample);
 109
 110             chunk_remaining_bytes = cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample);
 111
 112             assert(chunk_remaining_bytes >= 0);
 113             assert(chunk_remaining_bytes <= cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample));
 114         }
 115
 116         if (chunk_remaining_bytes <= cbSrcStream - offset_src)
 117         {
 118             if (SUCCEEDED(hr))
 119             {
 120                 memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, chunk_remaining_bytes);
 121                 hr = IMediaSample_SetActualDataLength(This->pCurrentSample, chunk_remaining_bytes + IMediaSample_GetActualDataLength(This->pCurrentSample));
 122                 assert(hr == S_OK);
 123             }
 124
 125             if (SUCCEEDED(hr))
 126             {
 127                 REFERENCE_TIME tAviStart, tAviStop;
 128
 129                 /* FIXME: hack */
 130                 if (pOutputPin->dwSamplesProcessed == 0) {
 131                     IMediaSample_SetDiscontinuity(This->pCurrentSample, TRUE);
 132                     IMediaSample_SetSyncPoint(This->pCurrentSample, TRUE);
 133                 }
 134
 135                 pOutputPin->dwSamplesProcessed++;
 136
 137                 if (pOutputPin->dwSampleSize)
 138                     tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec));
 139                 else
 140                     tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) / (float)pOutputPin->fSamplesPerSec);
 141                 if (pOutputPin->dwSampleSize)
 142                     tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec));
 143                 else
 144                     tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed / (float)pOutputPin->fSamplesPerSec);
 145
 146                 IMediaSample_SetTime(This->pCurrentSample, &tAviStart, &tAviStop);
 147
 148                 hr = OutputPin_SendSample(&pOutputPin->pin, This->pCurrentSample);
 149                 if (hr != S_OK && hr != VFW_E_NOT_CONNECTED)
 150                     ERR("Error sending sample (%x)\n", hr);
 151             }
 152
 153             if (This->pCurrentSample)
 154                 IMediaSample_Release(This->pCurrentSample);
 155
 156             This->pCurrentSample = NULL;
 157         }
 158         else
 159         {
 160             if (SUCCEEDED(hr))
 161             {
 162                 memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, cbSrcStream - offset_src);
 163                 IMediaSample_SetActualDataLength(This->pCurrentSample, cbSrcStream - offset_src + IMediaSample_GetActualDataLength(This->pCurrentSample));
 164             }
 165             bMoreData = FALSE;
 166         }
 167         offset_src += chunk_remaining_bytes;
 168     }
 169
 170     if (tStop >= This->EndOfFile)
 171     {
 172         int i;
 173
 174         TRACE("End of file reached\n");
 175
 176         for (i = 0; i < This->Parser.cStreams; i++)
 177         {
 178             IPin* ppin;
 179             HRESULT hr;
 180
 181             TRACE("Send End Of Stream to output pin %d\n", i);
 182
 183             hr = IPin_ConnectedTo(This->Parser.ppPins[i+1], &ppin);
 184             if (SUCCEEDED(hr))
 185             {
 186                 hr = IPin_EndOfStream(ppin);
 187                 IPin_Release(ppin);
 188             }
 189             if (FAILED(hr))
 190             {
 191                 ERR("%x\n", hr);
 192                 break;
 193             }
 194         }
 195
 196         /* Force the pullpin thread to stop */
 197         hr = S_FALSE;
 198     }
 199
 200     return hr;
 201 }
 202
 203 static HRESULT WAVEParser_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
 204 {
 205     if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream))
 206         return S_FALSE;
 207     if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_WAVE))
 208         return S_OK;
 209     if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_AU) || IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_AIFF))
 210         FIXME("AU and AIFF files not supported yet!\n");
 211     return S_FALSE;
 212 }
 213
 214 static HRESULT WAVEParser_InputPin_PreConnect(IPin * iface, IPin * pConnectPin)
 215 {
 216     PullPin *This = (PullPin *)iface;
 217     HRESULT hr;
 218     RIFFLIST list;
 219     RIFFCHUNK chunk;
 220     LONGLONG pos = 0; /* in bytes */
 221     PIN_INFO piOutput;
 222     ALLOCATOR_PROPERTIES props;
 223     AM_MEDIA_TYPE amt;
 224     float fSamplesPerSec = 0.0f;
 225     DWORD dwSampleSize = 0;
 226     DWORD dwLength = 0;
 227     WAVEParserImpl * pWAVEParser = (WAVEParserImpl *)This->pin.pinInfo.pFilter;
 228
 229     piOutput.dir = PINDIR_OUTPUT;
 230     piOutput.pFilter = (IBaseFilter *)This;
 231     lstrcpynW(piOutput.achName, wcsOutputPinName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
 232
 233     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
 234     pos += sizeof(list);
 235
 236     if (list.fcc != ckidRIFF)
 237     {
 238         ERR("Input stream not a RIFF file\n");
 239         return E_FAIL;
 240     }
 241     if (list.cb > 1 * 1024 * 1024 * 1024) /* cannot be more than 1Gb in size */
 242     {
 243         ERR("Input stream violates RIFF spec\n");
 244         return E_FAIL;
 245     }
 246     if (list.fccListType != mmioFOURCC('W','A','V','E'))
 247     {
 248         ERR("Input stream not an WAVE RIFF file\n");
 249         return E_FAIL;
 250     }
 251
 252     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
 253     pos += sizeof(chunk);
 254     if (chunk.fcc != mmioFOURCC('f','m','t',' '))
 255     {
 256         ERR("Expected 'fmt ' chunk, but got %.04s\n", (LPSTR)&chunk.fcc);
 257         return E_FAIL;
 258     }
 259
 260     memcpy(&amt.majortype, &MEDIATYPE_Audio, sizeof(GUID));
 261     memcpy(&amt.formattype, &FORMAT_WaveFormatEx, sizeof(GUID));
 262     amt.cbFormat = chunk.cb;
 263     amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
 264     amt.pUnk = NULL;
 265     hr = IAsyncReader_SyncRead(This->pReader, pos, amt.cbFormat, amt.pbFormat);
 266     memcpy(&amt.subtype, &MEDIATYPE_Audio, sizeof(GUID));
 267     amt.subtype.Data1 = ((WAVEFORMATEX*)amt.pbFormat)->wFormatTag;
 268
 269     pos += chunk.cb;
 270     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
 271     if (chunk.fcc == mmioFOURCC('f','a','c','t'))
 272     {
 273         FIXME("'fact' chunk not supported yet\n");
 274         pos += sizeof(chunk) + chunk.cb;
 275         hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(chunk), (BYTE *)&chunk);
 276     }
 277     if (chunk.fcc != mmioFOURCC('d','a','t','a'))
 278     {
 279         ERR("Expected 'data' chunk, but got %.04s\n", (LPSTR)&chunk.fcc);
 280         return E_FAIL;
 281     }
 282
 283     if (hr == S_OK)
 284     {
 285         pWAVEParser->StartOfFile = MEDIATIME_FROM_BYTES(pos + sizeof(RIFFCHUNK));
 286         pWAVEParser->EndOfFile = MEDIATIME_FROM_BYTES(pos + chunk.cb + sizeof(RIFFCHUNK));
 287     }
 288
 289     if (hr != S_OK)
 290         return E_FAIL;
 291
 292     props.cbAlign = ((WAVEFORMATEX*)amt.pbFormat)->nBlockAlign;
 293     props.cbPrefix = 0;
 294     props.cbBuffer = 4096;
 295     props.cBuffers = 2;
 296
 297     hr = Parser_AddPin(&(pWAVEParser->Parser), &piOutput, &props, &amt, fSamplesPerSec, dwSampleSize, dwLength);
 298
 299     TRACE("WAVE File ok\n");
 300
 301     return hr;
 302 }
 303
 304 static HRESULT WAVEParser_Cleanup(LPVOID iface)
 305 {
 306     WAVEParserImpl *This = (WAVEParserImpl*)iface;
 307
 308     TRACE("(%p)->()\n", This);
 309
 310     if (This->pCurrentSample)
 311         IMediaSample_Release(This->pCurrentSample);
 312     This->pCurrentSample = NULL;
 313
 314     return S_OK;
 315 }
 316
 317 HRESULT WAVEParser_create(IUnknown * pUnkOuter, LPVOID * ppv)
 318 {
 319     HRESULT hr;
 320     WAVEParserImpl * This;
 321
 322     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 323
 324     *ppv = NULL;
 325
 326     if (pUnkOuter)
 327         return CLASS_E_NOAGGREGATION;
 328
 329     /* Note: This memory is managed by the transform filter once created */
 330     This = CoTaskMemAlloc(sizeof(WAVEParserImpl));
 331
 332     This->pCurrentSample = NULL;
 333
 334     hr = Parser_Create(&(This->Parser), &CLSID_WAVEParser, WAVEParser_Sample, WAVEParser_QueryAccept, WAVEParser_InputPin_PreConnect, WAVEParser_Cleanup);
 335
 336     if (FAILED(hr))
 337         return hr;
 338
 339     *ppv = (LPVOID)This;
 340
 341     return hr;
 342 }