dlls/quartz/audren.c

   1 /*
   2  * Audio Renderer (CLSID_AudioRender)
   3  *
   4  * FIXME
   5  *  - implements IRefereneceClock.
   6  *  - implements seeking.
   7  *
   8  * hidenori@a2.ctktv.ne.jp
   9  */
  10
  11 #include "config.h"
  12
  13 #include "windef.h"
  14 #include "winbase.h"
  15 #include "wingdi.h"
  16 #include "winuser.h"
  17 #include "mmsystem.h"
  18 #include "winerror.h"
  19 #include "wine/obj_base.h"
  20 #include "wine/obj_oleaut.h"
  21 #include "strmif.h"
  22 #include "control.h"
  23 #include "vfwmsgs.h"
  24 #include "uuids.h"
  25 #include "evcode.h"
  26
  27 #include "debugtools.h"
  28 DEFAULT_DEBUG_CHANNEL(quartz);
  29
  30 #include "quartz_private.h"
  31 #include "audren.h"
  32
  33
  34 static const WCHAR QUARTZ_AudioRender_Name[] =
  35 { 'A','u','d','i','o',' ','R','e','n','d','e','r',0 };
  36 static const WCHAR QUARTZ_AudioRenderPin_Name[] =
  37 { 'I','n',0 };
  38
  39
  40
  41 /***************************************************************************
  42  *
  43  *      CAudioRendererImpl waveOut methods (internal)
  44  *
  45  */
  46
  47 static
  48 HRESULT QUARTZ_HRESULT_From_MMRESULT( MMRESULT mr )
  49 {
  50         HRESULT hr = E_FAIL;
  51
  52         switch ( mr )
  53         {
  54         case MMSYSERR_NOERROR:
  55                 hr = S_OK;
  56                 break;
  57         case MMSYSERR_NOMEM:
  58                 hr = E_OUTOFMEMORY;
  59                 break;
  60         }
  61
  62         return hr;
  63 }
  64
  65 void CAudioRendererImpl_waveOutEventCallback(
  66         HWAVEOUT hwo, UINT uMsg,
  67         DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
  68 {
  69         CAudioRendererImpl* This = (CAudioRendererImpl*)dwInstance;
  70
  71         if ( uMsg == WOM_DONE )
  72                 SetEvent( This->m_hEventRender );
  73 }
  74
  75 static
  76 void CAudioRendererImpl_waveOutReset(
  77         CAudioRendererImpl* This )
  78 {
  79         if ( !This->m_fWaveOutInit )
  80                 return;
  81
  82         waveOutReset( This->m_hWaveOut );
  83         SetEvent( This->m_hEventRender );
  84 }
  85
  86 static
  87 void CAudioRendererImpl_waveOutUninit(
  88         CAudioRendererImpl* This )
  89 {
  90         DWORD i;
  91
  92         TRACE("(%p)\n",This);
  93
  94         if ( !This->m_fWaveOutInit )
  95                 return;
  96
  97         waveOutReset( This->m_hWaveOut );
  98         SetEvent( This->m_hEventRender );
  99
 100         for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
 101         {
 102                 if ( This->m_hdr[i].dwFlags & WHDR_PREPARED )
 103                 {
 104                         waveOutUnprepareHeader(
 105                                 This->m_hWaveOut,
 106                                 &This->m_hdr[i], sizeof(WAVEHDR) );
 107                         This->m_hdr[i].dwFlags = 0;
 108                 }
 109                 if ( This->m_hdr[i].lpData != NULL )
 110                 {
 111                         QUARTZ_FreeMem( This->m_hdr[i].lpData );
 112                         This->m_hdr[i].lpData = NULL;
 113                 }
 114         }
 115
 116         waveOutClose( This->m_hWaveOut );
 117         This->m_hWaveOut = (HWAVEOUT)NULL;
 118         if ( This->m_hEventRender != (HANDLE)NULL )
 119         {
 120                 CloseHandle( This->m_hEventRender );
 121                 This->m_hEventRender = (HANDLE)NULL;
 122         }
 123
 124         This->m_fWaveOutInit = FALSE;
 125 }
 126
 127 static
 128 HRESULT CAudioRendererImpl_waveOutInit(
 129         CAudioRendererImpl* This, WAVEFORMATEX* pwfx )
 130 {
 131         MMRESULT mr;
 132         HRESULT hr;
 133         DWORD i;
 134         DWORD dwBlockSize;
 135
 136         if ( This->m_fWaveOutInit )
 137                 return E_UNEXPECTED;
 138
 139         if ( pwfx == NULL )
 140                 return E_POINTER;
 141         if ( pwfx->nBlockAlign == 0 )
 142                 return E_INVALIDARG;
 143
 144         This->m_hEventRender = (HANDLE)NULL;
 145         This->m_hWaveOut = (HWAVEOUT)NULL;
 146         This->m_dwBlockSize = 0;
 147         This->m_phdrCur = NULL;
 148         ZeroMemory( &This->m_hdr, sizeof(This->m_hdr) );
 149
 150
 151         mr = waveOutOpen(
 152                 &This->m_hWaveOut, WAVE_MAPPER, pwfx,
 153                 (DWORD)CAudioRendererImpl_waveOutEventCallback, (DWORD)This,
 154                 CALLBACK_FUNCTION );
 155         hr = QUARTZ_HRESULT_From_MMRESULT( mr );
 156         if ( FAILED(hr) )
 157                 return hr;
 158         This->m_fWaveOutInit = TRUE;
 159
 160         This->m_hEventRender = CreateEventA(
 161                 NULL, TRUE, TRUE, NULL );
 162         if ( This->m_hEventRender == (HANDLE)NULL )
 163         {
 164                 hr = E_OUTOFMEMORY;
 165                 goto err;
 166         }
 167
 168         dwBlockSize = pwfx->nAvgBytesPerSec / pwfx->nBlockAlign;
 169         if ( dwBlockSize == 0 )
 170                 dwBlockSize = 1;
 171         dwBlockSize *= pwfx->nBlockAlign;
 172         This->m_dwBlockSize = dwBlockSize;
 173
 174         for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
 175         {
 176                 This->m_hdr[i].lpData = (CHAR*)QUARTZ_AllocMem( dwBlockSize );
 177                 if ( This->m_hdr[i].lpData == NULL )
 178                 {
 179                         hr = E_OUTOFMEMORY;
 180                         goto err;
 181                 }
 182                 mr = waveOutPrepareHeader(
 183                                 This->m_hWaveOut,
 184                                 &This->m_hdr[i], sizeof(WAVEHDR) );
 185                 hr = QUARTZ_HRESULT_From_MMRESULT( mr );
 186                 if ( FAILED(hr) )
 187                         goto err;
 188                 This->m_hdr[i].dwFlags |= WHDR_DONE;
 189                 This->m_hdr[i].dwBufferLength = dwBlockSize;
 190                 This->m_hdr[i].dwUser = i;
 191         }
 192
 193         return S_OK;
 194 err:
 195         CAudioRendererImpl_waveOutUninit(This);
 196         return hr;
 197 }
 198
 199 static
 200 WAVEHDR* CAudioRendererImpl_waveOutGetBuffer(
 201         CAudioRendererImpl* This )
 202 {
 203         DWORD i;
 204
 205         if ( !This->m_fWaveOutInit )
 206                 return NULL;
 207
 208         if ( This->m_phdrCur != NULL )
 209                 return This->m_phdrCur;
 210
 211         for ( i = 0; i < WINE_QUARTZ_WAVEOUT_COUNT; i++ )
 212         {
 213                 if ( This->m_hdr[i].dwFlags & WHDR_DONE )
 214                 {
 215                         This->m_phdrCur = &(This->m_hdr[i]);
 216                         This->m_phdrCur->dwFlags &= ~WHDR_DONE;
 217                         This->m_phdrCur->dwBufferLength = 0;
 218                         return This->m_phdrCur;
 219                 }
 220         }
 221
 222         return NULL;
 223 }
 224
 225 static
 226 HRESULT CAudioRendererImpl_waveOutWriteData(
 227         CAudioRendererImpl* This,
 228         const BYTE* pData, DWORD cbData, DWORD* pcbWritten )
 229 {
 230         DWORD   cbAvail;
 231
 232         *pcbWritten = 0;
 233
 234         if ( !This->m_fWaveOutInit )
 235                 return E_UNEXPECTED;
 236
 237         if ( cbData == 0 )
 238                 return S_OK;
 239
 240         if ( CAudioRendererImpl_waveOutGetBuffer(This) == NULL )
 241                 return S_FALSE;
 242
 243         cbAvail = This->m_dwBlockSize - This->m_phdrCur->dwBufferLength;
 244         if ( cbAvail > cbData )
 245                 cbAvail = cbData;
 246         memcpy( This->m_phdrCur->lpData, pData, cbAvail );
 247         pData += cbAvail;
 248         cbData -= cbAvail;
 249         This->m_phdrCur->dwBufferLength += cbAvail;
 250
 251         *pcbWritten = cbAvail;
 252
 253         return S_OK;
 254 }
 255
 256 static
 257 HRESULT CAudioRendererImpl_waveOutFlush(
 258         CAudioRendererImpl* This )
 259 {
 260         MMRESULT mr;
 261         HRESULT hr;
 262
 263         if ( !This->m_fWaveOutInit )
 264                 return E_UNEXPECTED;
 265         if ( This->m_phdrCur == NULL )
 266                 return E_UNEXPECTED;
 267
 268         if ( This->m_phdrCur->dwBufferLength == 0 )
 269                 return S_OK;
 270
 271         mr = waveOutWrite(
 272                 This->m_hWaveOut,
 273                 This->m_phdrCur, sizeof(WAVEHDR) );
 274         hr = QUARTZ_HRESULT_From_MMRESULT( mr );
 275         if ( FAILED(hr) )
 276                 return hr;
 277
 278         This->m_phdrCur = NULL;
 279         return S_OK;
 280 }
 281
 282 static
 283 HRESULT CAudioRendererImpl_waveOutGetVolume(
 284         CAudioRendererImpl* This,
 285         DWORD* pdwLeft, DWORD* pdwRight )
 286 {
 287         MMRESULT mr;
 288         HRESULT hr;
 289         DWORD   dwVol;
 290
 291         if ( !This->m_fWaveOutInit )
 292                 return E_UNEXPECTED;
 293
 294         mr = waveOutGetVolume(
 295                 This->m_hWaveOut, &dwVol );
 296         hr = QUARTZ_HRESULT_From_MMRESULT( mr );
 297         if ( FAILED(hr) )
 298                 return hr;
 299
 300         *pdwLeft = LOWORD(dwVol);
 301         *pdwRight = HIWORD(dwVol);
 302
 303         return NOERROR;
 304 }
 305
 306 static
 307 HRESULT CAudioRendererImpl_waveOutSetVolume(
 308         CAudioRendererImpl* This,
 309         DWORD dwLeft, DWORD dwRight )
 310 {
 311         MMRESULT mr;
 312         DWORD   dwVol;
 313
 314         if ( !This->m_fWaveOutInit )
 315                 return E_UNEXPECTED;
 316
 317         dwVol = dwLeft | (dwRight<<16);
 318
 319         mr = waveOutSetVolume(
 320                 This->m_hWaveOut, dwVol );
 321         return QUARTZ_HRESULT_From_MMRESULT( mr );
 322 }
 323
 324 /***************************************************************************
 325  *
 326  *      CAudioRendererImpl methods
 327  *
 328  */
 329
 330
 331 static HRESULT CAudioRendererImpl_OnActive( CBaseFilterImpl* pImpl )
 332 {
 333         CAudioRendererImpl_THIS(pImpl,basefilter);
 334         WAVEFORMATEX*   pwfx;
 335
 336         FIXME( "(%p)\n", This );
 337
 338         if ( This->pPin->pin.pmtConn == NULL )
 339                 return NOERROR;
 340
 341         pwfx = (WAVEFORMATEX*)This->pPin->pin.pmtConn->pbFormat;
 342         if ( pwfx == NULL )
 343                 return E_FAIL;
 344
 345         This->m_fInFlush = FALSE;
 346
 347         return CAudioRendererImpl_waveOutInit(This,pwfx);
 348 }
 349
 350 static HRESULT CAudioRendererImpl_OnInactive( CBaseFilterImpl* pImpl )
 351 {
 352         CAudioRendererImpl_THIS(pImpl,basefilter);
 353
 354         FIXME( "(%p)\n", This );
 355
 356         CAudioRendererImpl_waveOutUninit(This);
 357
 358         This->m_fInFlush = FALSE;
 359
 360         TRACE("returned\n" );
 361
 362         return NOERROR;
 363 }
 364
 365 static const CBaseFilterHandlers filterhandlers =
 366 {
 367         CAudioRendererImpl_OnActive, /* pOnActive */
 368         CAudioRendererImpl_OnInactive, /* pOnInactive */
 369         NULL, /* pOnStop */
 370 };
 371
 372 /***************************************************************************
 373  *
 374  *      CAudioRendererPinImpl methods
 375  *
 376  */
 377
 378 static HRESULT CAudioRendererPinImpl_CheckMediaType( CPinBaseImpl* pImpl, const AM_MEDIA_TYPE* pmt )
 379 {
 380         CAudioRendererPinImpl_THIS(pImpl,pin);
 381         const WAVEFORMATEX* pwfx;
 382
 383         TRACE("(%p,%p)\n",This,pmt);
 384
 385         if ( !IsEqualGUID( &pmt->majortype, &MEDIATYPE_Audio ) )
 386                 return E_FAIL;
 387         if ( !IsEqualGUID( &pmt->subtype, &MEDIASUBTYPE_PCM ) )
 388                 return E_FAIL;
 389         if ( !IsEqualGUID( &pmt->formattype, &FORMAT_WaveFormatEx ) )
 390                 return E_FAIL;
 391         if ( pmt->cbFormat < (sizeof(WAVEFORMATEX)-sizeof(WORD)) )
 392                 return E_FAIL;
 393
 394         pwfx = (const WAVEFORMATEX*)pmt->pbFormat;
 395         if ( pwfx == NULL )
 396                 return E_FAIL;
 397         if ( pwfx->wFormatTag != 1 )
 398                 return E_FAIL;
 399
 400         return NOERROR;
 401 }
 402
 403 static HRESULT CAudioRendererPinImpl_Receive( CPinBaseImpl* pImpl, IMediaSample* pSample )
 404 {
 405         CAudioRendererPinImpl_THIS(pImpl,pin);
 406         HRESULT hr;
 407         BYTE*   pData = NULL;
 408         DWORD   dwDataLength;
 409         DWORD   dwWritten;
 410
 411         FIXME( "(%p,%p)\n",This,pSample );
 412
 413         if ( !This->pRender->m_fWaveOutInit )
 414                 return E_UNEXPECTED;
 415         if ( This->pRender->m_fInFlush )
 416                 return S_FALSE;
 417         if ( pSample == NULL )
 418                 return E_POINTER;
 419
 420         hr = IMediaSample_GetPointer( pSample, &pData );
 421         if ( FAILED(hr) )
 422                 return hr;
 423         dwDataLength = (DWORD)IMediaSample_GetActualDataLength( pSample );
 424
 425         while ( 1 )
 426         {
 427                 TRACE("trying to write %lu bytes\n",dwDataLength);
 428
 429                 ResetEvent( This->pRender->m_hEventRender );
 430                 hr = CAudioRendererImpl_waveOutWriteData(
 431                         This->pRender,pData,dwDataLength,&dwWritten);
 432                 if ( FAILED(hr) )
 433                         break;
 434                 if ( hr == S_FALSE )
 435                 {
 436                         WaitForSingleObject( This->pRender->m_hEventRender, INFINITE );
 437                         continue;
 438                 }
 439                 pData += dwWritten;
 440                 dwDataLength -= dwWritten;
 441                 hr = CAudioRendererImpl_waveOutFlush(This->pRender);
 442                 if ( FAILED(hr) )
 443                         break;
 444                 if ( dwDataLength == 0 )
 445                         break;
 446         }
 447
 448         return hr;
 449 }
 450
 451 static HRESULT CAudioRendererPinImpl_ReceiveCanBlock( CPinBaseImpl* pImpl )
 452 {
 453         CAudioRendererPinImpl_THIS(pImpl,pin);
 454
 455         TRACE( "(%p)\n", This );
 456
 457         /* might block. */
 458         return S_OK;
 459 }
 460
 461 static HRESULT CAudioRendererPinImpl_EndOfStream( CPinBaseImpl* pImpl )
 462 {
 463         CAudioRendererPinImpl_THIS(pImpl,pin);
 464
 465         FIXME( "(%p)\n", This );
 466
 467         This->pRender->m_fInFlush = FALSE;
 468
 469         /* FIXME - don't notify twice until stopped or seeked. */
 470         return CBaseFilterImpl_MediaEventNotify(
 471                 &This->pRender->basefilter, EC_COMPLETE,
 472                 (LONG_PTR)S_OK, (LONG_PTR)(IBaseFilter*)(This->pRender) );
 473 }
 474
 475 static HRESULT CAudioRendererPinImpl_BeginFlush( CPinBaseImpl* pImpl )
 476 {
 477         CAudioRendererPinImpl_THIS(pImpl,pin);
 478
 479         FIXME( "(%p)\n", This );
 480
 481         This->pRender->m_fInFlush = TRUE;
 482         CAudioRendererImpl_waveOutReset(This->pRender);
 483
 484         return NOERROR;
 485 }
 486
 487 static HRESULT CAudioRendererPinImpl_EndFlush( CPinBaseImpl* pImpl )
 488 {
 489         CAudioRendererPinImpl_THIS(pImpl,pin);
 490
 491         FIXME( "(%p)\n", This );
 492
 493         This->pRender->m_fInFlush = FALSE;
 494
 495         return NOERROR;
 496 }
 497
 498 static HRESULT CAudioRendererPinImpl_NewSegment( CPinBaseImpl* pImpl, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop, double rate )
 499 {
 500         CAudioRendererPinImpl_THIS(pImpl,pin);
 501
 502         FIXME( "(%p)\n", This );
 503
 504         This->pRender->m_fInFlush = FALSE;
 505
 506         return NOERROR;
 507 }
 508
 509 static const CBasePinHandlers pinhandlers =
 510 {
 511         NULL, /* pOnPreConnect */
 512         NULL, /* pOnPostConnect */
 513         NULL, /* pOnDisconnect */
 514         CAudioRendererPinImpl_CheckMediaType, /* pCheckMediaType */
 515         NULL, /* pQualityNotify */
 516         CAudioRendererPinImpl_Receive, /* pReceive */
 517         CAudioRendererPinImpl_ReceiveCanBlock, /* pReceiveCanBlock */
 518         CAudioRendererPinImpl_EndOfStream, /* pEndOfStream */
 519         CAudioRendererPinImpl_BeginFlush, /* pBeginFlush */
 520         CAudioRendererPinImpl_EndFlush, /* pEndFlush */
 521         CAudioRendererPinImpl_NewSegment, /* pNewSegment */
 522 };
 523
 524
 525 /***************************************************************************
 526  *
 527  *      new/delete CAudioRendererImpl
 528  *
 529  */
 530
 531 /* can I use offsetof safely? - FIXME? */
 532 static QUARTZ_IFEntry FilterIFEntries[] =
 533 {
 534   { &IID_IPersist, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
 535   { &IID_IMediaFilter, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
 536   { &IID_IBaseFilter, offsetof(CAudioRendererImpl,basefilter)-offsetof(CAudioRendererImpl,unk) },
 537   { &IID_IBasicAudio, offsetof(CAudioRendererImpl,basaud)-offsetof(CAudioRendererImpl,unk) },
 538 };
 539
 540 static void QUARTZ_DestroyAudioRenderer(IUnknown* punk)
 541 {
 542         CAudioRendererImpl_THIS(punk,unk);
 543
 544         TRACE( "(%p)\n", This );
 545
 546         if ( This->pPin != NULL )
 547         {
 548                 IUnknown_Release(This->pPin->unk.punkControl);
 549                 This->pPin = NULL;
 550         }
 551
 552         CAudioRendererImpl_UninitIBasicAudio(This);
 553         CBaseFilterImpl_UninitIBaseFilter(&This->basefilter);
 554 }
 555
 556 HRESULT QUARTZ_CreateAudioRenderer(IUnknown* punkOuter,void** ppobj)
 557 {
 558         CAudioRendererImpl*     This = NULL;
 559         HRESULT hr;
 560
 561         TRACE("(%p,%p)\n",punkOuter,ppobj);
 562
 563         This = (CAudioRendererImpl*)
 564                 QUARTZ_AllocObj( sizeof(CAudioRendererImpl) );
 565         if ( This == NULL )
 566                 return E_OUTOFMEMORY;
 567         This->pPin = NULL;
 568         This->m_fInFlush = FALSE;
 569         This->m_fWaveOutInit = FALSE;
 570         This->m_hEventRender = (HANDLE)NULL;
 571
 572         QUARTZ_IUnkInit( &This->unk, punkOuter );
 573
 574         hr = CBaseFilterImpl_InitIBaseFilter(
 575                 &This->basefilter,
 576                 This->unk.punkControl,
 577                 &CLSID_AudioRender,
 578                 QUARTZ_AudioRender_Name,
 579                 &filterhandlers );
 580         if ( SUCCEEDED(hr) )
 581         {
 582                 hr = CAudioRendererImpl_InitIBasicAudio(This);
 583                 if ( FAILED(hr) )
 584                 {
 585                         CBaseFilterImpl_UninitIBaseFilter(&This->basefilter);
 586                 }
 587         }
 588
 589         if ( FAILED(hr) )
 590         {
 591                 QUARTZ_FreeObj(This);
 592                 return hr;
 593         }
 594
 595         This->unk.pEntries = FilterIFEntries;
 596         This->unk.dwEntries = sizeof(FilterIFEntries)/sizeof(FilterIFEntries[0]);
 597         This->unk.pOnFinalRelease = QUARTZ_DestroyAudioRenderer;
 598
 599         hr = QUARTZ_CreateAudioRendererPin(
 600                 This,
 601                 &This->basefilter.csFilter,
 602                 &This->pPin );
 603         if ( SUCCEEDED(hr) )
 604                 hr = QUARTZ_CompList_AddComp(
 605                         This->basefilter.pInPins,
 606                         (IUnknown*)&This->pPin->pin,
 607                         NULL, 0 );
 608         if ( FAILED(hr) )
 609         {
 610                 IUnknown_Release( This->unk.punkControl );
 611                 return hr;
 612         }
 613
 614         *ppobj = (void*)&(This->unk);
 615
 616         return S_OK;
 617 }
 618
 619
 620 /***************************************************************************
 621  *
 622  *      new/delete CAudioRendererPinImpl
 623  *
 624  */
 625
 626 /* can I use offsetof safely? - FIXME? */
 627 static QUARTZ_IFEntry PinIFEntries[] =
 628 {
 629   { &IID_IPin, offsetof(CAudioRendererPinImpl,pin)-offsetof(CAudioRendererPinImpl,unk) },
 630   { &IID_IMemInputPin, offsetof(CAudioRendererPinImpl,meminput)-offsetof(CAudioRendererPinImpl,unk) },
 631 };
 632
 633 static void QUARTZ_DestroyAudioRendererPin(IUnknown* punk)
 634 {
 635         CAudioRendererPinImpl_THIS(punk,unk);
 636
 637         TRACE( "(%p)\n", This );
 638
 639         CPinBaseImpl_UninitIPin( &This->pin );
 640         CMemInputPinBaseImpl_UninitIMemInputPin( &This->meminput );
 641 }
 642
 643 HRESULT QUARTZ_CreateAudioRendererPin(
 644         CAudioRendererImpl* pFilter,
 645         CRITICAL_SECTION* pcsPin,
 646         CAudioRendererPinImpl** ppPin)
 647 {
 648         CAudioRendererPinImpl*  This = NULL;
 649         HRESULT hr;
 650
 651         TRACE("(%p,%p,%p)\n",pFilter,pcsPin,ppPin);
 652
 653         This = (CAudioRendererPinImpl*)
 654                 QUARTZ_AllocObj( sizeof(CAudioRendererPinImpl) );
 655         if ( This == NULL )
 656                 return E_OUTOFMEMORY;
 657
 658         QUARTZ_IUnkInit( &This->unk, NULL );
 659         This->pRender = pFilter;
 660
 661         hr = CPinBaseImpl_InitIPin(
 662                 &This->pin,
 663                 This->unk.punkControl,
 664                 pcsPin,
 665                 &pFilter->basefilter,
 666                 QUARTZ_AudioRenderPin_Name,
 667                 FALSE,
 668                 &pinhandlers );
 669
 670         if ( SUCCEEDED(hr) )
 671         {
 672                 hr = CMemInputPinBaseImpl_InitIMemInputPin(
 673                         &This->meminput,
 674                         This->unk.punkControl,
 675                         &This->pin );
 676                 if ( FAILED(hr) )
 677                 {
 678                         CPinBaseImpl_UninitIPin( &This->pin );
 679                 }
 680         }
 681
 682         if ( FAILED(hr) )
 683         {
 684                 QUARTZ_FreeObj(This);
 685                 return hr;
 686         }
 687
 688         This->unk.pEntries = PinIFEntries;
 689         This->unk.dwEntries = sizeof(PinIFEntries)/sizeof(PinIFEntries[0]);
 690         This->unk.pOnFinalRelease = QUARTZ_DestroyAudioRendererPin;
 691
 692         *ppPin = This;
 693
 694         TRACE("returned successfully.\n");
 695
 696         return S_OK;
 697 }
 698
 699
 700 /***************************************************************************
 701  *
 702  *      CAudioRendererImpl::IBasicAudio
 703  *
 704  */
 705
 706 static HRESULT WINAPI
 707 IBasicAudio_fnQueryInterface(IBasicAudio* iface,REFIID riid,void** ppobj)
 708 {
 709         CAudioRendererImpl_THIS(iface,basaud);
 710
 711         TRACE("(%p)->()\n",This);
 712
 713         return IUnknown_QueryInterface(This->unk.punkControl,riid,ppobj);
 714 }
 715
 716 static ULONG WINAPI
 717 IBasicAudio_fnAddRef(IBasicAudio* iface)
 718 {
 719         CAudioRendererImpl_THIS(iface,basaud);
 720
 721         TRACE("(%p)->()\n",This);
 722
 723         return IUnknown_AddRef(This->unk.punkControl);
 724 }
 725
 726 static ULONG WINAPI
 727 IBasicAudio_fnRelease(IBasicAudio* iface)
 728 {
 729         CAudioRendererImpl_THIS(iface,basaud);
 730
 731         TRACE("(%p)->()\n",This);
 732
 733         return IUnknown_Release(This->unk.punkControl);
 734 }
 735
 736 static HRESULT WINAPI
 737 IBasicAudio_fnGetTypeInfoCount(IBasicAudio* iface,UINT* pcTypeInfo)
 738 {
 739         CAudioRendererImpl_THIS(iface,basaud);
 740
 741         FIXME("(%p)->()\n",This);
 742
 743         return E_NOTIMPL;
 744 }
 745
 746 static HRESULT WINAPI
 747 IBasicAudio_fnGetTypeInfo(IBasicAudio* iface,UINT iTypeInfo, LCID lcid, ITypeInfo** ppobj)
 748 {
 749         CAudioRendererImpl_THIS(iface,basaud);
 750
 751         FIXME("(%p)->()\n",This);
 752
 753         return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI
 757 IBasicAudio_fnGetIDsOfNames(IBasicAudio* iface,REFIID riid, LPOLESTR* ppwszName, UINT cNames, LCID lcid, DISPID* pDispId)
 758 {
 759         CAudioRendererImpl_THIS(iface,basaud);
 760
 761         FIXME("(%p)->()\n",This);
 762
 763         return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI
 767 IBasicAudio_fnInvoke(IBasicAudio* iface,DISPID DispId, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarRes, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 768 {
 769         CAudioRendererImpl_THIS(iface,basaud);
 770
 771         FIXME("(%p)->()\n",This);
 772
 773         return E_NOTIMPL;
 774 }
 775
 776
 777 static HRESULT WINAPI
 778 IBasicAudio_fnput_Volume(IBasicAudio* iface,long lVol)
 779 {
 780         CAudioRendererImpl_THIS(iface,basaud);
 781
 782         FIXME("(%p)->()\n",This);
 783
 784         return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI
 788 IBasicAudio_fnget_Volume(IBasicAudio* iface,long* plVol)
 789 {
 790         CAudioRendererImpl_THIS(iface,basaud);
 791
 792         FIXME("(%p)->()\n",This);
 793
 794         return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI
 798 IBasicAudio_fnput_Balance(IBasicAudio* iface,long lBalance)
 799 {
 800         CAudioRendererImpl_THIS(iface,basaud);
 801
 802         FIXME("(%p)->()\n",This);
 803
 804         return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI
 808 IBasicAudio_fnget_Balance(IBasicAudio* iface,long* plBalance)
 809 {
 810         CAudioRendererImpl_THIS(iface,basaud);
 811
 812         FIXME("(%p)->()\n",This);
 813
 814         return E_NOTIMPL;
 815 }
 816
 817
 818 static ICOM_VTABLE(IBasicAudio) ibasicaudio =
 819 {
 820         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 821         /* IUnknown fields */
 822         IBasicAudio_fnQueryInterface,
 823         IBasicAudio_fnAddRef,
 824         IBasicAudio_fnRelease,
 825         /* IDispatch fields */
 826         IBasicAudio_fnGetTypeInfoCount,
 827         IBasicAudio_fnGetTypeInfo,
 828         IBasicAudio_fnGetIDsOfNames,
 829         IBasicAudio_fnInvoke,
 830         /* IBasicAudio fields */
 831         IBasicAudio_fnput_Volume,
 832         IBasicAudio_fnget_Volume,
 833         IBasicAudio_fnput_Balance,
 834         IBasicAudio_fnget_Balance,
 835 };
 836
 837
 838 HRESULT CAudioRendererImpl_InitIBasicAudio( CAudioRendererImpl* This )
 839 {
 840         TRACE("(%p)\n",This);
 841         ICOM_VTBL(&This->basaud) = &ibasicaudio;
 842
 843         return NOERROR;
 844 }
 845
 846 void CAudioRendererImpl_UninitIBasicAudio( CAudioRendererImpl* This )
 847 {
 848         TRACE("(%p)\n",This);
 849 }
 850