modules/access/dshow/filter.cpp

   1 /*****************************************************************************
   2  * filter.c : DirectShow access module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2002-2010 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_fourcc.h>
  34
  35 #ifndef _MSC_VER
  36     /* Work-around a bug in w32api-2.5 */
  37 #   define QACONTAINERFLAGS QACONTAINERFLAGS_SOMETHINGELSE
  38 #endif
  39
  40 #include "access.h"
  41 #include "filter.h"
  42 #include "vlc_dshow.h"
  43
  44 #define DEBUG_DSHOW 1
  45
  46 #define FILTER_NAME  L"VideoLAN Capture Filter"
  47 #define PIN_NAME     L"Capture"
  48
  49 void WINAPI FreeMediaType( AM_MEDIA_TYPE& mt )
  50 {
  51     if( mt.cbFormat != 0 )
  52     {
  53         CoTaskMemFree( (PVOID)mt.pbFormat );
  54         mt.cbFormat = 0;
  55         mt.pbFormat = NULL;
  56     }
  57     if( mt.pUnk != NULL )
  58     {
  59         mt.pUnk->Release();
  60         mt.pUnk = NULL;
  61     }
  62 }
  63
  64 HRESULT WINAPI CopyMediaType( AM_MEDIA_TYPE *pmtTarget,
  65                               const AM_MEDIA_TYPE *pmtSource )
  66 {
  67     *pmtTarget = *pmtSource;
  68
  69     if( !pmtSource || !pmtTarget ) return S_FALSE;
  70
  71     if( pmtSource->cbFormat && pmtSource->pbFormat )
  72     {
  73         pmtTarget->pbFormat = (PBYTE)CoTaskMemAlloc( pmtSource->cbFormat );
  74         if( pmtTarget->pbFormat == NULL )
  75         {
  76             pmtTarget->cbFormat = 0;
  77             return E_OUTOFMEMORY;
  78         }
  79         else
  80         {
  81             CopyMemory( (PVOID)pmtTarget->pbFormat, (PVOID)pmtSource->pbFormat,
  82                         pmtTarget->cbFormat );
  83         }
  84     }
  85     if( pmtTarget->pUnk != NULL )
  86     {
  87         pmtTarget->pUnk->AddRef();
  88     }
  89
  90     return S_OK;
  91 }
  92
  93 int GetFourCCFromMediaType( const AM_MEDIA_TYPE &media_type )
  94 {
  95     int i_fourcc = 0;
  96
  97     if( media_type.majortype == MEDIATYPE_Video )
  98     {
  99         /* currently only support this type of video info format */
 100         if( 1 /* media_type.formattype == FORMAT_VideoInfo */ )
 101         {
 102             /* Packed RGB formats */
 103             if( media_type.subtype == MEDIASUBTYPE_RGB1 )
 104                i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '1' );
 105             else if( media_type.subtype == MEDIASUBTYPE_RGB4 )
 106                i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '4' );
 107             else if( media_type.subtype == MEDIASUBTYPE_RGB8 )
 108                i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '8' );
 109             else if( media_type.subtype == MEDIASUBTYPE_RGB555 )
 110                i_fourcc = VLC_CODEC_RGB15;
 111             else if( media_type.subtype == MEDIASUBTYPE_RGB565 )
 112                i_fourcc = VLC_CODEC_RGB16;
 113             else if( media_type.subtype == MEDIASUBTYPE_RGB24 )
 114                i_fourcc = VLC_CODEC_RGB24;
 115             else if( media_type.subtype == MEDIASUBTYPE_RGB32 )
 116                i_fourcc = VLC_CODEC_RGB32;
 117             else if( media_type.subtype == MEDIASUBTYPE_ARGB32 )
 118                i_fourcc = VLC_CODEC_RGBA;
 119
 120             /* Planar YUV formats */
 121             else if( media_type.subtype == MEDIASUBTYPE_I420 )
 122                i_fourcc = VLC_CODEC_I420;
 123             else if( media_type.subtype == MEDIASUBTYPE_Y41P )
 124                i_fourcc = VLC_CODEC_I411;
 125             else if( media_type.subtype == MEDIASUBTYPE_YV12 )
 126                i_fourcc = VLC_CODEC_YV12;
 127             else if( media_type.subtype == MEDIASUBTYPE_IYUV )
 128                i_fourcc = VLC_CODEC_YV12;
 129             else if( media_type.subtype == MEDIASUBTYPE_YVU9 )
 130                i_fourcc = VLC_CODEC_I410;
 131
 132             /* Packed YUV formats */
 133             else if( media_type.subtype == MEDIASUBTYPE_YVYU )
 134                i_fourcc = VLC_CODEC_YVYU;
 135             else if( media_type.subtype == MEDIASUBTYPE_YUYV )
 136                i_fourcc = VLC_CODEC_YUYV;
 137             else if( media_type.subtype == MEDIASUBTYPE_Y411 )
 138                i_fourcc = VLC_FOURCC( 'I', '4', '1', 'N' );
 139             else if( media_type.subtype == MEDIASUBTYPE_Y211 )
 140                i_fourcc = VLC_CODEC_Y211;
 141             else if( media_type.subtype == MEDIASUBTYPE_YUY2 )
 142                i_fourcc = VLC_CODEC_YUYV;
 143             else if( media_type.subtype == MEDIASUBTYPE_UYVY )
 144                i_fourcc = VLC_CODEC_UYVY;
 145             /* HDYC uses UYVY sample positions but Rec709 colourimetry */
 146             /* FIXME: When VLC understands colourspace, something will need
 147              * to be added / changed here. Until then, just make it behave
 148              * like UYVY */
 149             else if( media_type.subtype == MEDIASUBTYPE_HDYC )
 150                 i_fourcc = VLC_CODEC_UYVY;
 151
 152             /* MPEG2 video elementary stream */
 153             else if( media_type.subtype == MEDIASUBTYPE_MPEG2_VIDEO )
 154                i_fourcc = VLC_CODEC_MPGV;
 155
 156             /* DivX video */
 157             else if( media_type.subtype == MEDIASUBTYPE_DIVX )
 158                i_fourcc = VLC_CODEC_MP4V;
 159
 160             /* DV formats */
 161             else if( media_type.subtype == MEDIASUBTYPE_dvsl )
 162                i_fourcc = VLC_CODEC_DV;
 163             else if( media_type.subtype == MEDIASUBTYPE_dvsd )
 164                i_fourcc = VLC_CODEC_DV;
 165             else if( media_type.subtype == MEDIASUBTYPE_dvhd )
 166                i_fourcc = VLC_CODEC_DV;
 167
 168             /* MJPEG format */
 169             else if( media_type.subtype == MEDIASUBTYPE_MJPG )
 170                 i_fourcc = VLC_CODEC_MJPG;
 171
 172         }
 173     }
 174     else if( media_type.majortype == MEDIATYPE_Audio )
 175     {
 176         /* currently only support this type of audio info format */
 177         if( media_type.formattype == FORMAT_WaveFormatEx )
 178         {
 179             if( media_type.subtype == MEDIASUBTYPE_PCM )
 180                 i_fourcc = VLC_FOURCC( 'a', 'r', 'a', 'w' );
 181             else if( media_type.subtype == MEDIASUBTYPE_IEEE_FLOAT )
 182                 i_fourcc = VLC_CODEC_FL32;
 183         }
 184     }
 185     else if( media_type.majortype == MEDIATYPE_Stream )
 186     {
 187         if( media_type.subtype == MEDIASUBTYPE_MPEG2_PROGRAM )
 188             i_fourcc = VLC_FOURCC( 'm', 'p', '2', 'p' );
 189         else if( media_type.subtype == MEDIASUBTYPE_MPEG2_TRANSPORT )
 190             i_fourcc = VLC_FOURCC( 'm', 'p', '2', 't' );
 191     }
 192
 193     return i_fourcc;
 194 }
 195
 196 /****************************************************************************
 197  * Implementation of our dummy directshow filter pin class
 198  ****************************************************************************/
 199
 200 CapturePin::CapturePin( vlc_object_t *_p_input, access_sys_t *_p_sys,
 201                         CaptureFilter *_p_filter,
 202                         AM_MEDIA_TYPE *mt, size_t mt_count )
 203   : p_input( _p_input ), p_sys( _p_sys ), p_filter( _p_filter ),
 204     p_connected_pin( NULL ),  media_types(mt), media_type_count(mt_count),
 205     i_ref( 1 )
 206 {
 207     cx_media_type.majortype = mt[0].majortype;
 208     cx_media_type.subtype   = GUID_NULL;
 209     cx_media_type.pbFormat  = NULL;
 210     cx_media_type.cbFormat  = 0;
 211     cx_media_type.pUnk      = NULL;
 212 }
 213
 214 CapturePin::~CapturePin()
 215 {
 216 #ifdef DEBUG_DSHOW
 217     msg_Dbg( p_input, "CapturePin::~CapturePin" );
 218 #endif
 219     for( size_t c=0; c<media_type_count; c++ )
 220     {
 221         FreeMediaType(media_types[c]);
 222     }
 223     FreeMediaType(cx_media_type);
 224 }
 225
 226 /**
 227  * Returns the complete queue of samples that have been received so far.
 228  * Lock the p_sys->lock before calling this function.
 229  * @param samples_queue [out] Empty queue that will get all elements from
 230  * the pin queue.
 231  * @return S_OK if a sample was available, S_FALSE if no sample was
 232  * available
 233  */
 234 HRESULT CapturePin::CustomGetSamples( deque<VLCMediaSample> &external_queue )
 235 {
 236 #if 0 //def DEBUG_DSHOW
 237     msg_Dbg( p_input, "CapturePin::CustomGetSamples: %d samples in the queue", samples_queue.size());
 238 #endif
 239
 240     if( !samples_queue.empty() )
 241     {
 242         external_queue.swap(samples_queue);
 243         return S_OK;
 244     }
 245     return S_FALSE;
 246 }
 247
 248 /**
 249  * Returns a sample from its sample queue. Proper locking must be done prior
 250  * to this call. Current dshow code protects the access to any sample queue
 251  * (audio and video) with the p_sys->lock
 252  * @param vlc_sample [out] Address of a sample if sucessfull. Undefined
 253  * otherwise.
 254  * @return S_OK if a sample was available, S_FALSE if no sample was
 255  * available
 256  */
 257 HRESULT CapturePin::CustomGetSample( VLCMediaSample *vlc_sample )
 258 {
 259 #if 0 //def DEBUG_DSHOW
 260     msg_Dbg( p_input, "CapturePin::CustomGetSample" );
 261 #endif
 262
 263     if( !samples_queue.empty() )
 264     {
 265         *vlc_sample = samples_queue.back();
 266         samples_queue.pop_back();
 267         return S_OK;
 268     }
 269     return S_FALSE;
 270 }
 271
 272 AM_MEDIA_TYPE &CapturePin::CustomGetMediaType()
 273 {
 274     return cx_media_type;
 275 }
 276
 277 /* IUnknown methods */
 278 STDMETHODIMP CapturePin::QueryInterface(REFIID riid, void **ppv)
 279 {
 280 #ifdef DEBUG_DSHOW_L1
 281     msg_Dbg( p_input, "CapturePin::QueryInterface" );
 282 #endif
 283
 284     if( riid == IID_IUnknown ||
 285         riid == IID_IPin )
 286     {
 287         AddRef();
 288         *ppv = (IPin *)this;
 289         return NOERROR;
 290     }
 291     if( riid == IID_IMemInputPin )
 292     {
 293         AddRef();
 294         *ppv = (IMemInputPin *)this;
 295         return NOERROR;
 296     }
 297     else
 298     {
 299 #ifdef DEBUG_DSHOW_L1
 300         msg_Dbg( p_input, "CapturePin::QueryInterface() failed for: "
 301                  "%04X-%02X-%02X-%02X%02X%02X%02X%02X%02X%02X%02X",
 302                  (int)riid.Data1, (int)riid.Data2, (int)riid.Data3,
 303                  static_cast<int>(riid.Data4[0]), (int)riid.Data4[1],
 304                  (int)riid.Data4[2], (int)riid.Data4[3],
 305                  (int)riid.Data4[4], (int)riid.Data4[5],
 306                  (int)riid.Data4[6], (int)riid.Data4[7] );
 307 #endif
 308         *ppv = NULL;
 309         return E_NOINTERFACE;
 310     }
 311 }
 312
 313 STDMETHODIMP_(ULONG) CapturePin::AddRef()
 314 {
 315 #ifdef DEBUG_DSHOW_L1
 316     msg_Dbg( p_input, "CapturePin::AddRef (ref: %i)", i_ref );
 317 #endif
 318
 319     return i_ref++;
 320 };
 321 STDMETHODIMP_(ULONG) CapturePin::Release()
 322 {
 323 #ifdef DEBUG_DSHOW_L1
 324     msg_Dbg( p_input, "CapturePin::Release (ref: %i)", i_ref );
 325 #endif
 326
 327     if( !InterlockedDecrement(&i_ref) ) delete this;
 328
 329     return 0;
 330 };
 331
 332 /* IPin methods */
 333 STDMETHODIMP CapturePin::Connect( IPin *,
 334                                   const AM_MEDIA_TYPE *pmt )
 335 {
 336     if( State_Running == p_filter->state )
 337     {
 338         msg_Dbg( p_input, "CapturePin::Connect [not stopped]" );
 339         return VFW_E_NOT_STOPPED;
 340     }
 341
 342     if( p_connected_pin )
 343     {
 344         msg_Dbg( p_input, "CapturePin::Connect [already connected]" );
 345         return VFW_E_ALREADY_CONNECTED;
 346     }
 347
 348     if( !pmt ) return S_OK;
 349
 350     if( GUID_NULL != pmt->majortype &&
 351         media_types[0].majortype != pmt->majortype )
 352     {
 353         msg_Dbg( p_input, "CapturePin::Connect [media major type mismatch]" );
 354         return S_FALSE;
 355     }
 356
 357     if( GUID_NULL != pmt->subtype && !GetFourCCFromMediaType(*pmt) )
 358     {
 359         msg_Dbg( p_input, "CapturePin::Connect [media subtype type "
 360                  "not supported]" );
 361         return S_FALSE;
 362     }
 363
 364     if( pmt->pbFormat && pmt->majortype == MEDIATYPE_Video  )
 365     {
 366         if( !((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biHeight ||
 367             !((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biWidth )
 368         {
 369             msg_Dbg( p_input, "CapturePin::Connect "
 370                      "[video width/height == 0 ]" );
 371             return S_FALSE;
 372         }
 373     }
 374
 375     msg_Dbg( p_input, "CapturePin::Connect [OK]" );
 376     return S_OK;
 377 }
 378 STDMETHODIMP CapturePin::ReceiveConnection( IPin * pConnector,
 379                                             const AM_MEDIA_TYPE *pmt )
 380 {
 381     if( State_Stopped != p_filter->state )
 382     {
 383         msg_Dbg( p_input, "CapturePin::ReceiveConnection [not stopped]" );
 384         return VFW_E_NOT_STOPPED;
 385     }
 386
 387     if( !pConnector || !pmt )
 388     {
 389         msg_Dbg( p_input, "CapturePin::ReceiveConnection [null pointer]" );
 390         return E_POINTER;
 391     }
 392
 393     if( p_connected_pin )
 394     {
 395         msg_Dbg( p_input, "CapturePin::ReceiveConnection [already connected]");
 396         return VFW_E_ALREADY_CONNECTED;
 397     }
 398
 399     if( S_OK != QueryAccept(pmt) )
 400     {
 401         msg_Dbg( p_input, "CapturePin::ReceiveConnection "
 402                  "[media type not accepted]" );
 403         return VFW_E_TYPE_NOT_ACCEPTED;
 404     }
 405
 406     msg_Dbg( p_input, "CapturePin::ReceiveConnection [OK]" );
 407
 408     p_connected_pin = pConnector;
 409     p_connected_pin->AddRef();
 410
 411     FreeMediaType( cx_media_type );
 412     return CopyMediaType( &cx_media_type, pmt );
 413 }
 414 STDMETHODIMP CapturePin::Disconnect()
 415 {
 416     if( ! p_connected_pin )
 417     {
 418         msg_Dbg( p_input, "CapturePin::Disconnect [not connected]" );
 419         return S_FALSE;
 420     }
 421
 422     msg_Dbg( p_input, "CapturePin::Disconnect [OK]" );
 423
 424     /* samples_queue was already flushed in EndFlush() */
 425
 426     p_connected_pin->Release();
 427     p_connected_pin = NULL;
 428     //FreeMediaType( cx_media_type );
 429     //cx_media_type.subtype = GUID_NULL;
 430
 431     return S_OK;
 432 }
 433 STDMETHODIMP CapturePin::ConnectedTo( IPin **pPin )
 434 {
 435     if( !p_connected_pin )
 436     {
 437         msg_Dbg( p_input, "CapturePin::ConnectedTo [not connected]" );
 438         return VFW_E_NOT_CONNECTED;
 439     }
 440
 441     p_connected_pin->AddRef();
 442     *pPin = p_connected_pin;
 443
 444     msg_Dbg( p_input, "CapturePin::ConnectedTo [OK]" );
 445
 446     return S_OK;
 447 }
 448 STDMETHODIMP CapturePin::ConnectionMediaType( AM_MEDIA_TYPE *pmt )
 449 {
 450     if( !p_connected_pin )
 451     {
 452         msg_Dbg( p_input, "CapturePin::ConnectionMediaType [not connected]" );
 453         return VFW_E_NOT_CONNECTED;
 454     }
 455
 456     return CopyMediaType( pmt, &cx_media_type );
 457 }
 458 STDMETHODIMP CapturePin::QueryPinInfo( PIN_INFO * pInfo )
 459 {
 460 #ifdef DEBUG_DSHOW
 461     msg_Dbg( p_input, "CapturePin::QueryPinInfo" );
 462 #endif
 463
 464     pInfo->pFilter = p_filter;
 465     if( p_filter ) p_filter->AddRef();
 466
 467     memcpy(pInfo->achName, PIN_NAME, sizeof(PIN_NAME));
 468     pInfo->dir = PINDIR_INPUT;
 469
 470     return NOERROR;
 471 }
 472 STDMETHODIMP CapturePin::QueryDirection( PIN_DIRECTION * pPinDir )
 473 {
 474 #ifdef DEBUG_DSHOW
 475     msg_Dbg( p_input, "CapturePin::QueryDirection" );
 476 #endif
 477
 478     *pPinDir = PINDIR_INPUT;
 479     return NOERROR;
 480 }
 481 STDMETHODIMP CapturePin::QueryId( LPWSTR * Id )
 482 {
 483 #ifdef DEBUG_DSHOW
 484     msg_Dbg( p_input, "CapturePin::QueryId" );
 485 #endif
 486
 487     *Id = (LPWSTR)L"VLC Capture Pin";
 488
 489     return S_OK;
 490 }
 491 STDMETHODIMP CapturePin::QueryAccept( const AM_MEDIA_TYPE *pmt )
 492 {
 493     if( State_Stopped != p_filter->state )
 494     {
 495         msg_Dbg( p_input, "CapturePin::QueryAccept [not stopped]" );
 496         return S_FALSE;
 497     }
 498
 499     if( media_types[0].majortype != pmt->majortype )
 500     {
 501         msg_Dbg( p_input, "CapturePin::QueryAccept [media type mismatch]" );
 502         return S_FALSE;
 503     }
 504
 505     int i_fourcc = GetFourCCFromMediaType(*pmt);
 506     if( !i_fourcc )
 507     {
 508         msg_Dbg( p_input, "CapturePin::QueryAccept "
 509                  "[media type not supported]" );
 510         return S_FALSE;
 511     }
 512
 513     if( pmt->majortype == MEDIATYPE_Video )
 514     {
 515         if( pmt->pbFormat &&
 516             ( (((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biHeight == 0) ||
 517               (((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biWidth == 0) ) )
 518         {
 519             msg_Dbg( p_input, "CapturePin::QueryAccept [video size wxh == 0]");
 520             return S_FALSE;
 521         }
 522
 523         msg_Dbg( p_input, "CapturePin::QueryAccept [OK] "
 524                  "(width=%ld, height=%ld, chroma=%4.4s, fps=%f)",
 525                  ((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biWidth,
 526                  ((VIDEOINFOHEADER *)pmt->pbFormat)->bmiHeader.biHeight,
 527                  (char *)&i_fourcc,
 528          10000000.0f/((float)((VIDEOINFOHEADER *)pmt->pbFormat)->AvgTimePerFrame) );
 529     }
 530     else if( pmt->majortype == MEDIATYPE_Audio )
 531     {
 532         msg_Dbg( p_input, "CapturePin::QueryAccept [OK] (channels=%d, "
 533                  "samples/sec=%lu, bits/samples=%d, format=%4.4s)",
 534                  ((WAVEFORMATEX *)pmt->pbFormat)->nChannels,
 535                  ((WAVEFORMATEX *)pmt->pbFormat)->nSamplesPerSec,
 536                  ((WAVEFORMATEX *)pmt->pbFormat)->wBitsPerSample,
 537                  (char *)&i_fourcc );
 538     }
 539     else
 540     {
 541         msg_Dbg( p_input, "CapturePin::QueryAccept [OK] (stream format=%4.4s)",
 542                  (char *)&i_fourcc );
 543     }
 544
 545     if( p_connected_pin )
 546     {
 547         FreeMediaType( cx_media_type );
 548         CopyMediaType( &cx_media_type, pmt );
 549     }
 550
 551     return S_OK;
 552 }
 553 STDMETHODIMP CapturePin::EnumMediaTypes( IEnumMediaTypes **ppEnum )
 554 {
 555 #ifdef DEBUG_DSHOW_L1
 556     msg_Dbg( p_input, "CapturePin::EnumMediaTypes" );
 557 #endif
 558
 559     *ppEnum = new CaptureEnumMediaTypes( p_input, this, NULL );
 560
 561     if( *ppEnum == NULL ) return E_OUTOFMEMORY;
 562
 563     return NOERROR;
 564 }
 565 STDMETHODIMP CapturePin::QueryInternalConnections( IPin**, ULONG * )
 566 {
 567 #ifdef DEBUG_DSHOW_L1
 568     msg_Dbg( p_input, "CapturePin::QueryInternalConnections" );
 569 #endif
 570     return E_NOTIMPL;
 571 }
 572 STDMETHODIMP CapturePin::EndOfStream( void )
 573 {
 574 #ifdef DEBUG_DSHOW
 575     msg_Dbg( p_input, "CapturePin::EndOfStream" );
 576 #endif
 577     return S_OK;
 578 }
 579 STDMETHODIMP CapturePin::BeginFlush( void )
 580 {
 581 #ifdef DEBUG_DSHOW
 582     msg_Dbg( p_input, "CapturePin::BeginFlush" );
 583 #endif
 584     return S_OK;
 585 }
 586 STDMETHODIMP CapturePin::EndFlush( void )
 587 {
 588 #ifdef DEBUG_DSHOW
 589     msg_Dbg( p_input, "CapturePin::EndFlush" );
 590 #endif
 591
 592     VLCMediaSample vlc_sample;
 593
 594     vlc_mutex_lock( &p_sys->lock );
 595     while( !samples_queue.empty() )
 596     {
 597         vlc_sample = samples_queue.back();
 598         samples_queue.pop_back();
 599         vlc_sample.p_sample->Release();
 600     }
 601     vlc_mutex_unlock( &p_sys->lock );
 602
 603     return S_OK;
 604 }
 605 STDMETHODIMP CapturePin::NewSegment( REFERENCE_TIME, REFERENCE_TIME, double )
 606 {
 607 #ifdef DEBUG_DSHOW
 608     msg_Dbg( p_input, "CapturePin::NewSegment" );
 609 #endif
 610     return S_OK;
 611 }
 612
 613 /* IMemInputPin methods */
 614 STDMETHODIMP CapturePin::GetAllocator( IMemAllocator ** )
 615 {
 616 #ifdef DEBUG_DSHOW
 617     msg_Dbg( p_input, "CapturePin::GetAllocator" );
 618 #endif
 619
 620     return VFW_E_NO_ALLOCATOR;
 621 }
 622 STDMETHODIMP CapturePin::NotifyAllocator( IMemAllocator *, BOOL )
 623 {
 624 #ifdef DEBUG_DSHOW
 625     msg_Dbg( p_input, "CapturePin::NotifyAllocator" );
 626 #endif
 627
 628     return S_OK;
 629 }
 630 STDMETHODIMP CapturePin::GetAllocatorRequirements( ALLOCATOR_PROPERTIES * )
 631 {
 632 #ifdef DEBUG_DSHOW
 633     msg_Dbg( p_input, "CapturePin::GetAllocatorRequirements" );
 634 #endif
 635
 636     return E_NOTIMPL;
 637 }
 638 STDMETHODIMP CapturePin::Receive( IMediaSample *pSample )
 639 {
 640 #if 0 //def DEBUG_DSHOW
 641     msg_Dbg( p_input, "CapturePin::Receive" );
 642 #endif
 643
 644     pSample->AddRef();
 645     mtime_t i_timestamp = mdate() * 10;
 646     VLCMediaSample vlc_sample = {pSample, i_timestamp};
 647
 648     vlc_mutex_lock( &p_sys->lock );
 649     samples_queue.push_front( vlc_sample );
 650
 651     /* Make sure we don't cache too many samples */
 652     if( samples_queue.size() > 10 )
 653     {
 654         vlc_sample = samples_queue.back();
 655         samples_queue.pop_back();
 656         msg_Dbg( p_input, "CapturePin::Receive trashing late input sample" );
 657         vlc_sample.p_sample->Release();
 658     }
 659
 660     vlc_cond_signal( &p_sys->wait );
 661     vlc_mutex_unlock( &p_sys->lock );
 662
 663     return S_OK;
 664 }
 665 STDMETHODIMP CapturePin::ReceiveMultiple( IMediaSample **pSamples,
 666                                           long nSamples,
 667                                           long *nSamplesProcessed )
 668 {
 669     HRESULT hr = S_OK;
 670
 671     *nSamplesProcessed = 0;
 672     while( nSamples-- > 0 )
 673     {
 674          hr = Receive( pSamples[*nSamplesProcessed] );
 675          if( hr != S_OK ) break;
 676          (*nSamplesProcessed)++;
 677     }
 678     return hr;
 679 }
 680 STDMETHODIMP CapturePin::ReceiveCanBlock( void )
 681 {
 682 #ifdef DEBUG_DSHOW
 683     msg_Dbg( p_input, "CapturePin::ReceiveCanBlock" );
 684 #endif
 685
 686     return S_FALSE; /* Thou shalt not block */
 687 }
 688
 689 /****************************************************************************
 690  * Implementation of our dummy directshow filter class
 691  ****************************************************************************/
 692 CaptureFilter::CaptureFilter( vlc_object_t *_p_input, access_sys_t *p_sys,
 693                               AM_MEDIA_TYPE *mt, size_t mt_count )
 694   : p_input( _p_input ),
 695     p_pin( new CapturePin( _p_input, p_sys, this, mt, mt_count ) ),
 696     state( State_Stopped ), i_ref( 1 )
 697 {
 698 }
 699
 700 CaptureFilter::~CaptureFilter()
 701 {
 702 #ifdef DEBUG_DSHOW
 703     msg_Dbg( p_input, "CaptureFilter::~CaptureFilter" );
 704 #endif
 705     p_pin->Release();
 706 }
 707
 708 /* IUnknown methods */
 709 STDMETHODIMP CaptureFilter::QueryInterface( REFIID riid, void **ppv )
 710 {
 711 #ifdef DEBUG_DSHOW_L1
 712     msg_Dbg( p_input, "CaptureFilter::QueryInterface" );
 713 #endif
 714
 715     if( riid == IID_IUnknown )
 716     {
 717         AddRef();
 718         *ppv = (IUnknown *)this;
 719         return NOERROR;
 720     }
 721     if( riid == IID_IPersist )
 722     {
 723         AddRef();
 724         *ppv = (IPersist *)this;
 725         return NOERROR;
 726     }
 727     if( riid == IID_IMediaFilter )
 728     {
 729         AddRef();
 730         *ppv = (IMediaFilter *)this;
 731         return NOERROR;
 732     }
 733     if( riid == IID_IBaseFilter )
 734     {
 735         AddRef();
 736         *ppv = (IBaseFilter *)this;
 737         return NOERROR;
 738     }
 739     else
 740     {
 741 #ifdef DEBUG_DSHOW_L1
 742         msg_Dbg( p_input, "CaptureFilter::QueryInterface() failed for: "
 743                  "%04X-%02X-%02X-%02X%02X%02X%02X%02X%02X%02X%02X",
 744                  (int)riid.Data1, (int)riid.Data2, (int)riid.Data3,
 745                  static_cast<int>(riid.Data4[0]), (int)riid.Data4[1],
 746                  (int)riid.Data4[2], (int)riid.Data4[3],
 747                  (int)riid.Data4[4], (int)riid.Data4[5],
 748                  (int)riid.Data4[6], (int)riid.Data4[7] );
 749 #endif
 750         *ppv = NULL;
 751         return E_NOINTERFACE;
 752     }
 753 };
 754 STDMETHODIMP_(ULONG) CaptureFilter::AddRef()
 755 {
 756 #ifdef DEBUG_DSHOW_L1
 757     msg_Dbg( p_input, "CaptureFilter::AddRef (ref: %i)", i_ref );
 758 #endif
 759
 760     return i_ref++;
 761 };
 762 STDMETHODIMP_(ULONG) CaptureFilter::Release()
 763 {
 764 #ifdef DEBUG_DSHOW_L1
 765     msg_Dbg( p_input, "CaptureFilter::Release (ref: %i)", i_ref );
 766 #endif
 767
 768     if( !InterlockedDecrement(&i_ref) ) delete this;
 769
 770     return 0;
 771 };
 772
 773 /* IPersist method */
 774 STDMETHODIMP CaptureFilter::GetClassID(CLSID *)
 775 {
 776 #ifdef DEBUG_DSHOW
 777     msg_Dbg( p_input, "CaptureFilter::GetClassID" );
 778 #endif
 779     return E_NOTIMPL;
 780 };
 781
 782 /* IMediaFilter methods */
 783 STDMETHODIMP CaptureFilter::GetState(DWORD, FILTER_STATE *State)
 784 {
 785 #ifdef DEBUG_DSHOW
 786     msg_Dbg( p_input, "CaptureFilter::GetState %i", state );
 787 #endif
 788
 789     *State = state;
 790     return S_OK;
 791 };
 792 STDMETHODIMP CaptureFilter::SetSyncSource(IReferenceClock *)
 793 {
 794 #ifdef DEBUG_DSHOW
 795     msg_Dbg( p_input, "CaptureFilter::SetSyncSource" );
 796 #endif
 797
 798     return S_OK;
 799 };
 800 STDMETHODIMP CaptureFilter::GetSyncSource(IReferenceClock **pClock)
 801 {
 802 #ifdef DEBUG_DSHOW
 803     msg_Dbg( p_input, "CaptureFilter::GetSyncSource" );
 804 #endif
 805
 806     *pClock = NULL;
 807     return NOERROR;
 808 };
 809 STDMETHODIMP CaptureFilter::Stop()
 810 {
 811 #ifdef DEBUG_DSHOW
 812     msg_Dbg( p_input, "CaptureFilter::Stop" );
 813 #endif
 814
 815     p_pin->EndFlush();
 816
 817     state = State_Stopped;
 818     return S_OK;
 819 };
 820 STDMETHODIMP CaptureFilter::Pause()
 821 {
 822 #ifdef DEBUG_DSHOW
 823     msg_Dbg( p_input, "CaptureFilter::Pause" );
 824 #endif
 825
 826     state = State_Paused;
 827     return S_OK;
 828 };
 829 STDMETHODIMP CaptureFilter::Run(REFERENCE_TIME)
 830 {
 831 #ifdef DEBUG_DSHOW
 832     msg_Dbg( p_input, "CaptureFilter::Run" );
 833 #endif
 834
 835     state = State_Running;
 836     return S_OK;
 837 };
 838
 839 /* IBaseFilter methods */
 840 STDMETHODIMP CaptureFilter::EnumPins( IEnumPins ** ppEnum )
 841 {
 842 #ifdef DEBUG_DSHOW
 843     msg_Dbg( p_input, "CaptureFilter::EnumPins" );
 844 #endif
 845
 846     /* Create a new ref counted enumerator */
 847     *ppEnum = new CaptureEnumPins( p_input, this, NULL );
 848     return *ppEnum == NULL ? E_OUTOFMEMORY : NOERROR;
 849 };
 850 STDMETHODIMP CaptureFilter::FindPin( LPCWSTR, IPin ** )
 851 {
 852 #ifdef DEBUG_DSHOW
 853     msg_Dbg( p_input, "CaptureFilter::FindPin" );
 854 #endif
 855     return E_NOTIMPL;
 856 };
 857 STDMETHODIMP CaptureFilter::QueryFilterInfo( FILTER_INFO * pInfo )
 858 {
 859 #ifdef DEBUG_DSHOW
 860     msg_Dbg( p_input, "CaptureFilter::QueryFilterInfo" );
 861 #endif
 862
 863     memcpy(pInfo->achName, FILTER_NAME, sizeof(FILTER_NAME));
 864
 865     pInfo->pGraph = p_graph;
 866     if( p_graph ) p_graph->AddRef();
 867
 868     return NOERROR;
 869 };
 870 STDMETHODIMP CaptureFilter::JoinFilterGraph( IFilterGraph * pGraph,
 871                                              LPCWSTR )
 872 {
 873 #ifdef DEBUG_DSHOW
 874     msg_Dbg( p_input, "CaptureFilter::JoinFilterGraph" );
 875 #endif
 876
 877     p_graph = pGraph;
 878
 879     return NOERROR;
 880 };
 881 STDMETHODIMP CaptureFilter::QueryVendorInfo( LPWSTR* )
 882 {
 883 #ifdef DEBUG_DSHOW
 884     msg_Dbg( p_input, "CaptureFilter::QueryVendorInfo" );
 885 #endif
 886     return E_NOTIMPL;
 887 };
 888
 889 /* Custom methods */
 890 CapturePin *CaptureFilter::CustomGetPin()
 891 {
 892     return p_pin;
 893 }
 894
 895 /****************************************************************************
 896  * Implementation of our dummy directshow enumpins class
 897  ****************************************************************************/
 898
 899 CaptureEnumPins::CaptureEnumPins( vlc_object_t *_p_input,
 900                                   CaptureFilter *_p_filter,
 901                                   CaptureEnumPins *pEnumPins )
 902   : p_input( _p_input ), p_filter( _p_filter ), i_ref( 1 )
 903 {
 904     /* Hold a reference count on our filter */
 905     p_filter->AddRef();
 906
 907     /* Are we creating a new enumerator */
 908
 909     if( pEnumPins == NULL )
 910     {
 911         i_position = 0;
 912     }
 913     else
 914     {
 915         i_position = pEnumPins->i_position;
 916     }
 917 }
 918
 919 CaptureEnumPins::~CaptureEnumPins()
 920 {
 921 #ifdef DEBUG_DSHOW_L1
 922     msg_Dbg( p_input, "CaptureEnumPins::~CaptureEnumPins" );
 923 #endif
 924     p_filter->Release();
 925 }
 926
 927 /* IUnknown methods */
 928 STDMETHODIMP CaptureEnumPins::QueryInterface( REFIID riid, void **ppv )
 929 {
 930 #ifdef DEBUG_DSHOW_L1
 931     msg_Dbg( p_input, "CaptureEnumPins::QueryInterface" );
 932 #endif
 933
 934     if( riid == IID_IUnknown ||
 935         riid == IID_IEnumPins )
 936     {
 937         AddRef();
 938         *ppv = (IEnumPins *)this;
 939         return NOERROR;
 940     }
 941     else
 942     {
 943         *ppv = NULL;
 944         return E_NOINTERFACE;
 945     }
 946 };
 947 STDMETHODIMP_(ULONG) CaptureEnumPins::AddRef()
 948 {
 949 #ifdef DEBUG_DSHOW_L1
 950     msg_Dbg( p_input, "CaptureEnumPins::AddRef (ref: %i)", i_ref );
 951 #endif
 952
 953     return i_ref++;
 954 };
 955 STDMETHODIMP_(ULONG) CaptureEnumPins::Release()
 956 {
 957 #ifdef DEBUG_DSHOW_L1
 958     msg_Dbg( p_input, "CaptureEnumPins::Release (ref: %i)", i_ref );
 959 #endif
 960
 961     if( !InterlockedDecrement(&i_ref) ) delete this;
 962
 963     return 0;
 964 };
 965
 966 /* IEnumPins */
 967 STDMETHODIMP CaptureEnumPins::Next( ULONG cPins, IPin ** ppPins,
 968                                     ULONG * pcFetched )
 969 {
 970 #ifdef DEBUG_DSHOW_L1
 971     msg_Dbg( p_input, "CaptureEnumPins::Next" );
 972 #endif
 973
 974     unsigned int i_fetched = 0;
 975
 976     if( i_position < 1 && cPins > 0 )
 977     {
 978         IPin *pPin = p_filter->CustomGetPin();
 979         *ppPins = pPin;
 980         pPin->AddRef();
 981         i_fetched = 1;
 982         i_position++;
 983     }
 984
 985     if( pcFetched ) *pcFetched = i_fetched;
 986
 987     return (i_fetched == cPins) ? S_OK : S_FALSE;
 988 };
 989 STDMETHODIMP CaptureEnumPins::Skip( ULONG cPins )
 990 {
 991 #ifdef DEBUG_DSHOW_L1
 992     msg_Dbg( p_input, "CaptureEnumPins::Skip" );
 993 #endif
 994
 995     i_position += cPins;
 996
 997     if( i_position > 1 )
 998     {
 999         return S_FALSE;
1000     }
1001
1002     return S_OK;
1003 };
1004 STDMETHODIMP CaptureEnumPins::Reset()
1005 {
1006 #ifdef DEBUG_DSHOW_L1
1007     msg_Dbg( p_input, "CaptureEnumPins::Reset" );
1008 #endif
1009
1010     i_position = 0;
1011     return S_OK;
1012 };
1013 STDMETHODIMP CaptureEnumPins::Clone( IEnumPins **ppEnum )
1014 {
1015 #ifdef DEBUG_DSHOW_L1
1016     msg_Dbg( p_input, "CaptureEnumPins::Clone" );
1017 #endif
1018
1019     *ppEnum = new CaptureEnumPins( p_input, p_filter, this );
1020     if( *ppEnum == NULL ) return E_OUTOFMEMORY;
1021
1022     return NOERROR;
1023 };
1024
1025 /****************************************************************************
1026  * Implementation of our dummy directshow enummediatypes class
1027  ****************************************************************************/
1028 CaptureEnumMediaTypes::CaptureEnumMediaTypes( vlc_object_t *_p_input,
1029     CapturePin *_p_pin, CaptureEnumMediaTypes *pEnumMediaTypes )
1030   : p_input( _p_input ), p_pin( _p_pin ), i_ref( 1 )
1031 {
1032     /* Hold a reference count on our filter */
1033     p_pin->AddRef();
1034
1035     /* Are we creating a new enumerator */
1036     if( pEnumMediaTypes == NULL )
1037     {
1038         CopyMediaType(&cx_media_type, &p_pin->cx_media_type);
1039         i_position = 0;
1040     }
1041     else
1042     {
1043         CopyMediaType(&cx_media_type, &pEnumMediaTypes->cx_media_type);
1044         i_position = pEnumMediaTypes->i_position;
1045     }
1046 }
1047
1048 CaptureEnumMediaTypes::~CaptureEnumMediaTypes()
1049 {
1050 #ifdef DEBUG_DSHOW_L1
1051     msg_Dbg( p_input, "CaptureEnumMediaTypes::~CaptureEnumMediaTypes" );
1052 #endif
1053     FreeMediaType(cx_media_type);
1054     p_pin->Release();
1055 }
1056
1057 /* IUnknown methods */
1058 STDMETHODIMP CaptureEnumMediaTypes::QueryInterface( REFIID riid, void **ppv )
1059 {
1060 #ifdef DEBUG_DSHOW_L1
1061     msg_Dbg( p_input, "CaptureEnumMediaTypes::QueryInterface" );
1062 #endif
1063
1064     if( riid == IID_IUnknown ||
1065         riid == IID_IEnumMediaTypes )
1066     {
1067         AddRef();
1068         *ppv = (IEnumMediaTypes *)this;
1069         return NOERROR;
1070     }
1071     else
1072     {
1073         *ppv = NULL;
1074         return E_NOINTERFACE;
1075     }
1076 };
1077 STDMETHODIMP_(ULONG) CaptureEnumMediaTypes::AddRef()
1078 {
1079 #ifdef DEBUG_DSHOW_L1
1080     msg_Dbg( p_input, "CaptureEnumMediaTypes::AddRef (ref: %i)", i_ref );
1081 #endif
1082
1083     return i_ref++;
1084 };
1085 STDMETHODIMP_(ULONG) CaptureEnumMediaTypes::Release()
1086 {
1087 #ifdef DEBUG_DSHOW_L1
1088     msg_Dbg( p_input, "CaptureEnumMediaTypes::Release (ref: %i)", i_ref );
1089 #endif
1090
1091     if( !InterlockedDecrement(&i_ref) ) delete this;
1092
1093     return 0;
1094 };
1095
1096 /* IEnumMediaTypes */
1097 STDMETHODIMP CaptureEnumMediaTypes::Next( ULONG cMediaTypes,
1098                                           AM_MEDIA_TYPE ** ppMediaTypes,
1099                                           ULONG * pcFetched )
1100 {
1101 #ifdef DEBUG_DSHOW_L1
1102     msg_Dbg( p_input, "CaptureEnumMediaTypes::Next " );
1103 #endif
1104     ULONG copied = 0;
1105     ULONG offset = 0;
1106     ULONG max = p_pin->media_type_count;
1107
1108     if( ! ppMediaTypes )
1109         return E_POINTER;
1110
1111     if( (! pcFetched)  && (cMediaTypes > 1) )
1112        return E_POINTER;
1113
1114     /*
1115     ** use connection media type as first entry in iterator if it exists
1116     */
1117     copied = 0;
1118     if( cx_media_type.subtype != GUID_NULL )
1119     {
1120         ++max;
1121         if( i_position == 0 )
1122         {
1123             ppMediaTypes[copied] =
1124                 (AM_MEDIA_TYPE *)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
1125             if( CopyMediaType(ppMediaTypes[copied], &cx_media_type) != S_OK )
1126                 return E_OUTOFMEMORY;
1127             ++i_position;
1128             ++copied;
1129         }
1130     }
1131
1132     while( (copied < cMediaTypes) && (i_position < max)  )
1133     {
1134         ppMediaTypes[copied] =
1135             (AM_MEDIA_TYPE *)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
1136         if( CopyMediaType( ppMediaTypes[copied],
1137                            &p_pin->media_types[i_position-offset]) != S_OK )
1138             return E_OUTOFMEMORY;
1139
1140         ++copied;
1141         ++i_position;
1142     }
1143
1144     if( pcFetched )  *pcFetched = copied;
1145
1146     return (copied == cMediaTypes) ? S_OK : S_FALSE;
1147 };
1148 STDMETHODIMP CaptureEnumMediaTypes::Skip( ULONG cMediaTypes )
1149 {
1150     ULONG max =  p_pin->media_type_count;
1151     if( cx_media_type.subtype != GUID_NULL )
1152     {
1153         max = 1;
1154     }
1155 #ifdef DEBUG_DSHOW_L1
1156     msg_Dbg( p_input, "CaptureEnumMediaTypes::Skip" );
1157 #endif
1158
1159     i_position += cMediaTypes;
1160     return (i_position < max) ? S_OK : S_FALSE;
1161 };
1162 STDMETHODIMP CaptureEnumMediaTypes::Reset()
1163 {
1164 #ifdef DEBUG_DSHOW_L1
1165     msg_Dbg( p_input, "CaptureEnumMediaTypes::Reset" );
1166 #endif
1167
1168     FreeMediaType(cx_media_type);
1169     CopyMediaType(&cx_media_type, &p_pin->cx_media_type);
1170     i_position = 0;
1171     return S_OK;
1172 };
1173 STDMETHODIMP CaptureEnumMediaTypes::Clone( IEnumMediaTypes **ppEnum )
1174 {
1175 #ifdef DEBUG_DSHOW_L1
1176     msg_Dbg( p_input, "CaptureEnumMediaTypes::Clone" );
1177 #endif
1178
1179     *ppEnum = new CaptureEnumMediaTypes( p_input, p_pin, this );
1180     if( *ppEnum == NULL ) return E_OUTOFMEMORY;
1181
1182     return NOERROR;
1183 };