git.sesse.net Git - vlc/blob - modules/access/dshow/dshow.cpp

   1 /*****************************************************************************
   2  * dshow.cpp : DirectShow access module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2002, 2003 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Gildas Bazin <gbazin@videolan.org>
   8  *         Damien Fouilleul <damienf@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #define __STDC_FORMAT_MACROS 1
  34 #include <inttypes.h>
  35
  36 #include <vlc_common.h>
  37 #include <vlc_plugin.h>
  38 #include <vlc_input.h>
  39 #include <vlc_access.h>
  40 #include <vlc_demux.h>
  41 #include <vlc_vout.h>
  42 #include <vlc_interface.h>
  43
  44 #include "common.h"
  45 #include "filter.h"
  46
  47 /*****************************************************************************
  48  * Access: local prototypes
  49  *****************************************************************************/
  50 static block_t *ReadCompressed( access_t * );
  51 static int AccessControl ( access_t *, int, va_list );
  52
  53 static int Demux       ( demux_t * );
  54 static int DemuxControl( demux_t *, int, va_list );
  55
  56 static int OpenDevice( vlc_object_t *, access_sys_t *, string, bool );
  57 static IBaseFilter *FindCaptureDevice( vlc_object_t *, string *,
  58                                        list<string> *, bool );
  59 static size_t EnumDeviceCaps( vlc_object_t *, IBaseFilter *,
  60                               int, int, int, int, int, int,
  61                               AM_MEDIA_TYPE *mt, size_t );
  62 static bool ConnectFilters( vlc_object_t *, access_sys_t *,
  63                             IBaseFilter *, CaptureFilter * );
  64 static int FindDevicesCallback( vlc_object_t *, char const *,
  65                                 vlc_value_t, vlc_value_t, void * );
  66 static int ConfigDevicesCallback( vlc_object_t *, char const *,
  67                                   vlc_value_t, vlc_value_t, void * );
  68
  69 static void ShowPropertyPage( IUnknown * );
  70 static void ShowDeviceProperties( vlc_object_t *, ICaptureGraphBuilder2 *,
  71                                   IBaseFilter *, bool );
  72 static void ShowTunerProperties( vlc_object_t *, ICaptureGraphBuilder2 *,
  73                                  IBaseFilter *, bool );
  74 static void ConfigTuner( vlc_object_t *, ICaptureGraphBuilder2 *,
  75                          IBaseFilter * );
  76
  77 /*****************************************************************************
  78  * Module descriptor
  79  *****************************************************************************/
  80 static const char *const ppsz_vdev[] = { "", "none" };
  81 static const char *const ppsz_vdev_text[] = { N_("Default"), N_("None") };
  82 static const char *const ppsz_adev[] = { "", "none" };
  83 static const char *const ppsz_adev_text[] = { N_("Default"), N_("None") };
  84 static const int pi_tuner_input[] = { 0, 1, 2 };
  85 static const char *const ppsz_tuner_input_text[] =
  86     {N_("Default"), N_("Cable"), N_("Antenna")};
  87 static const int pi_amtuner_mode[]  = { AMTUNER_MODE_DEFAULT,
  88                                  AMTUNER_MODE_TV,
  89                                  AMTUNER_MODE_FM_RADIO,
  90                                  AMTUNER_MODE_AM_RADIO,
  91                                  AMTUNER_MODE_DSS };
  92 static const char *const ppsz_amtuner_mode_text[] = { N_("Default"),
  93                                           N_("TV"),
  94                                           N_("FM radio"),
  95                                           N_("AM radio"),
  96                                           N_("DSS") };
  97
  98 #define CACHING_TEXT N_("Caching value in ms")
  99 #define CACHING_LONGTEXT N_( \
 100     "Caching value for DirectShow streams. " \
 101     "This value should be set in millisecondss." )
 102 #define VDEV_TEXT N_("Video device name")
 103 #define VDEV_LONGTEXT N_( \
 104     "Name of the video device that will be used by the " \
 105     "DirectShow plugin. If you don't specify anything, the default device " \
 106     "will be used.")
 107 #define ADEV_TEXT N_("Audio device name")
 108 #define ADEV_LONGTEXT N_( \
 109     "Name of the audio device that will be used by the " \
 110     "DirectShow plugin. If you don't specify anything, the default device " \
 111     "will be used. ")
 112 #define SIZE_TEXT N_("Video size")
 113 #define SIZE_LONGTEXT N_( \
 114     "Size of the video that will be displayed by the " \
 115     "DirectShow plugin. If you don't specify anything the default size for " \
 116     "your device will be used. You can specify a standard size (cif, d1, ...) or <width>x<height>.")
 117 #define CHROMA_TEXT N_("Video input chroma format")
 118 #define CHROMA_LONGTEXT N_( \
 119     "Force the DirectShow video input to use a specific chroma format " \
 120     "(eg. I420 (default), RV24, etc.)")
 121 #define FPS_TEXT N_("Video input frame rate")
 122 #define FPS_LONGTEXT N_( \
 123     "Force the DirectShow video input to use a specific frame rate" \
 124     "(eg. 0 means default, 25, 29.97, 50, 59.94, etc.)")
 125 #define CONFIG_TEXT N_("Device properties")
 126 #define CONFIG_LONGTEXT N_( \
 127     "Show the properties dialog of the selected device before starting the " \
 128     "stream.")
 129 #define TUNER_TEXT N_("Tuner properties")
 130 #define TUNER_LONGTEXT N_( \
 131     "Show the tuner properties [channel selection] page." )
 132 #define CHANNEL_TEXT N_("Tuner TV Channel")
 133 #define CHANNEL_LONGTEXT N_( \
 134     "Set the TV channel the tuner will set to " \
 135     "(0 means default)." )
 136 #define COUNTRY_TEXT N_("Tuner country code")
 137 #define COUNTRY_LONGTEXT N_( \
 138     "Set the tuner country code that establishes the current " \
 139     "channel-to-frequency mapping (0 means default)." )
 140 #define TUNER_INPUT_TEXT N_("Tuner input type")
 141 #define TUNER_INPUT_LONGTEXT N_( \
 142     "Select the tuner input type (Cable/Antenna)." )
 143 #define VIDEO_IN_TEXT N_("Video input pin")
 144 #define VIDEO_IN_LONGTEXT N_( \
 145   "Select the video input source, such as composite, s-video, " \
 146   "or tuner. Since these settings are hardware-specific, you should find good " \
 147   "settings in the \"Device config\" area, and use those numbers here. -1 " \
 148   "means that settings will not be changed.")
 149 #define AUDIO_IN_TEXT N_("Audio input pin")
 150 #define AUDIO_IN_LONGTEXT N_( \
 151   "Select the audio input source. See the \"video input\" option." )
 152 #define VIDEO_OUT_TEXT N_("Video output pin")
 153 #define VIDEO_OUT_LONGTEXT N_( \
 154   "Select the video output type. See the \"video input\" option." )
 155 #define AUDIO_OUT_TEXT N_("Audio output pin")
 156 #define AUDIO_OUT_LONGTEXT N_( \
 157   "Select the audio output type. See the \"video input\" option." )
 158
 159 #define AMTUNER_MODE_TEXT N_("AM Tuner mode")
 160 #define AMTUNER_MODE_LONGTEXT N_( \
 161     "AM Tuner mode. Can be one of DEFAULT, TV, AM_RADIO, FM_RADIO or DSS.")
 162
 163 static int  CommonOpen ( vlc_object_t *, access_sys_t *, bool );
 164 static void CommonClose( vlc_object_t *, access_sys_t * );
 165
 166 static int  AccessOpen ( vlc_object_t * );
 167 static void AccessClose( vlc_object_t * );
 168
 169 static int  DemuxOpen  ( vlc_object_t * );
 170 static void DemuxClose ( vlc_object_t * );
 171
 172 vlc_module_begin();
 173     set_shortname( N_("DirectShow") );
 174     set_description( N_("DirectShow input") );
 175     set_category( CAT_INPUT );
 176     set_subcategory( SUBCAT_INPUT_ACCESS );
 177     add_integer( "dshow-caching", (mtime_t)(0.2*CLOCK_FREQ) / 1000, NULL,
 178                  CACHING_TEXT, CACHING_LONGTEXT, true );
 179
 180     add_string( "dshow-vdev", NULL, NULL, VDEV_TEXT, VDEV_LONGTEXT, false);
 181         change_string_list( ppsz_vdev, ppsz_vdev_text, FindDevicesCallback );
 182         change_action_add( FindDevicesCallback, N_("Refresh list") );
 183         change_action_add( ConfigDevicesCallback, N_("Configure") );
 184
 185     add_string( "dshow-adev", NULL, NULL, ADEV_TEXT, ADEV_LONGTEXT, false);
 186         change_string_list( ppsz_adev, ppsz_adev_text, FindDevicesCallback );
 187         change_action_add( FindDevicesCallback, N_("Refresh list") );
 188         change_action_add( ConfigDevicesCallback, N_("Configure") );
 189
 190     add_string( "dshow-size", NULL, NULL, SIZE_TEXT, SIZE_LONGTEXT, false);
 191
 192     add_string( "dshow-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT,
 193                 true );
 194
 195     add_float( "dshow-fps", 0.0f, NULL, FPS_TEXT, FPS_LONGTEXT,
 196                 true );
 197
 198     add_bool( "dshow-config", false, NULL, CONFIG_TEXT, CONFIG_LONGTEXT,
 199               true );
 200
 201     add_bool( "dshow-tuner", false, NULL, TUNER_TEXT, TUNER_LONGTEXT,
 202               true );
 203
 204     add_integer( "dshow-tuner-channel", 0, NULL, CHANNEL_TEXT,
 205                  CHANNEL_LONGTEXT, true );
 206
 207     add_integer( "dshow-tuner-country", 0, NULL, COUNTRY_TEXT,
 208                  COUNTRY_LONGTEXT, true );
 209
 210     add_integer( "dshow-tuner-input", 0, NULL, TUNER_INPUT_TEXT,
 211                  TUNER_INPUT_LONGTEXT, true );
 212         change_integer_list( pi_tuner_input, ppsz_tuner_input_text, 0 );
 213
 214     add_integer( "dshow-video-input",  -1, NULL, VIDEO_IN_TEXT,
 215                  VIDEO_IN_LONGTEXT, true );
 216
 217     add_integer( "dshow-audio-input",  -1, NULL, AUDIO_IN_TEXT,
 218                  AUDIO_IN_LONGTEXT, true );
 219
 220     add_integer( "dshow-video-output", -1, NULL, VIDEO_OUT_TEXT,
 221                  VIDEO_OUT_LONGTEXT, true );
 222
 223     add_integer( "dshow-audio-output", -1, NULL, AUDIO_OUT_TEXT,
 224                  AUDIO_OUT_LONGTEXT, true );
 225
 226     add_integer( "dshow-amtuner-mode", AMTUNER_MODE_TV, NULL,
 227                 AMTUNER_MODE_TEXT, AMTUNER_MODE_LONGTEXT, false);
 228         change_integer_list( pi_amtuner_mode, ppsz_amtuner_mode_text, 0 );
 229
 230     add_shortcut( "dshow" );
 231     set_capability( "access_demux", 0 );
 232     set_callbacks( DemuxOpen, DemuxClose );
 233
 234     add_submodule();
 235     set_description( N_("DirectShow input") );
 236     set_capability( "access", 0 );
 237     set_callbacks( AccessOpen, AccessClose );
 238
 239 vlc_module_end();
 240
 241 /*****************************************************************************
 242  * DirectShow elementary stream descriptor
 243  *****************************************************************************/
 244 typedef struct dshow_stream_t
 245 {
 246     string          devicename;
 247     IBaseFilter     *p_device_filter;
 248     CaptureFilter   *p_capture_filter;
 249     AM_MEDIA_TYPE   mt;
 250
 251     union
 252     {
 253       VIDEOINFOHEADER video;
 254       WAVEFORMATEX    audio;
 255
 256     } header;
 257
 258     int             i_fourcc;
 259     es_out_id_t     *p_es;
 260
 261     bool      b_pts;
 262 } dshow_stream_t;
 263
 264 /*****************************************************************************
 265  * DirectShow utility functions
 266  *****************************************************************************/
 267 static void CreateDirectShowGraph( access_sys_t *p_sys )
 268 {
 269     p_sys->i_crossbar_route_depth = 0;
 270
 271     /* Create directshow filter graph */
 272     if( SUCCEEDED( CoCreateInstance( CLSID_FilterGraph, 0, CLSCTX_INPROC,
 273                        (REFIID)IID_IFilterGraph, (void **)&p_sys->p_graph) ) )
 274     {
 275         /* Create directshow capture graph builder if available */
 276         if( SUCCEEDED( CoCreateInstance( CLSID_CaptureGraphBuilder2, 0,
 277                          CLSCTX_INPROC, (REFIID)IID_ICaptureGraphBuilder2,
 278                          (void **)&p_sys->p_capture_graph_builder2 ) ) )
 279         {
 280             p_sys->p_capture_graph_builder2->
 281                 SetFiltergraph((IGraphBuilder *)p_sys->p_graph);
 282         }
 283
 284         p_sys->p_graph->QueryInterface( IID_IMediaControl,
 285                                         (void **)&p_sys->p_control );
 286     }
 287 }
 288
 289 static void DeleteDirectShowGraph( access_sys_t *p_sys )
 290 {
 291     DeleteCrossbarRoutes( p_sys );
 292
 293     /* Remove filters from graph */
 294     for( int i = 0; i < p_sys->i_streams; i++ )
 295     {
 296         p_sys->p_graph->RemoveFilter( p_sys->pp_streams[i]->p_capture_filter );
 297         p_sys->p_graph->RemoveFilter( p_sys->pp_streams[i]->p_device_filter );
 298         p_sys->pp_streams[i]->p_capture_filter->Release();
 299         p_sys->pp_streams[i]->p_device_filter->Release();
 300     }
 301
 302     /* Release directshow objects */
 303     if( p_sys->p_control )
 304     {
 305         p_sys->p_control->Release();
 306         p_sys->p_control = NULL;
 307     }
 308     if( p_sys->p_capture_graph_builder2 )
 309     {
 310         p_sys->p_capture_graph_builder2->Release();
 311         p_sys->p_capture_graph_builder2 = NULL;
 312     }
 313
 314     if( p_sys->p_graph )
 315     {
 316         p_sys->p_graph->Release();
 317         p_sys->p_graph = NULL;
 318     }
 319 }
 320
 321 /*****************************************************************************
 322  * CommonOpen: open direct show device
 323  *****************************************************************************/
 324 static int CommonOpen( vlc_object_t *p_this, access_sys_t *p_sys,
 325                        bool b_access_demux )
 326 {
 327     vlc_value_t  val;
 328     int i;
 329
 330     /* Get/parse options and open device(s) */
 331     string vdevname, adevname;
 332     int i_width = 0, i_height = 0, i_chroma = 0;
 333     bool b_audio = true;
 334
 335     var_Create( p_this, "dshow-config", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 336     var_Create( p_this, "dshow-tuner", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 337     var_Create( p_this, "dshow-vdev", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 338     var_Get( p_this, "dshow-vdev", &val );
 339     if( val.psz_string ) vdevname = string( val.psz_string );
 340     free( val.psz_string );
 341
 342     var_Create( p_this, "dshow-adev", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 343     var_Get( p_this, "dshow-adev", &val );
 344     if( val.psz_string ) adevname = string( val.psz_string );
 345     free( val.psz_string );
 346
 347     static struct {char *psz_size; int  i_width; int  i_height;} size_table[] =
 348     { { "subqcif", 128, 96 }, { "qsif", 160, 120 }, { "qcif", 176, 144 },
 349       { "sif", 320, 240 }, { "cif", 352, 288 }, { "d1", 640, 480 },
 350       { 0, 0, 0 },
 351     };
 352
 353     var_Create( p_this, "dshow-size", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 354     var_Get( p_this, "dshow-size", &val );
 355     if( val.psz_string && *val.psz_string )
 356     {
 357         for( i = 0; size_table[i].psz_size; i++ )
 358         {
 359             if( !strcmp( val.psz_string, size_table[i].psz_size ) )
 360             {
 361                 i_width = size_table[i].i_width;
 362                 i_height = size_table[i].i_height;
 363                 break;
 364             }
 365         }
 366         if( !size_table[i].psz_size ) /* Try to parse "WidthxHeight" */
 367         {
 368             char *psz_parser;
 369             i_width = strtol( val.psz_string, &psz_parser, 0 );
 370             if( *psz_parser == 'x' || *psz_parser == 'X')
 371             {
 372                 i_height = strtol( psz_parser + 1, &psz_parser, 0 );
 373             }
 374             msg_Dbg( p_this, "width x height %dx%d", i_width, i_height );
 375         }
 376     }
 377     free( val.psz_string );
 378
 379     p_sys->b_chroma = false;
 380     var_Create( p_this, "dshow-chroma", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 381     var_Get( p_this, "dshow-chroma", &val );
 382     if( val.psz_string && strlen( val.psz_string ) >= 4 )
 383     {
 384         i_chroma = VLC_FOURCC( val.psz_string[0], val.psz_string[1],
 385                                val.psz_string[2], val.psz_string[3] );
 386         p_sys->b_chroma = true;
 387     }
 388     free( val.psz_string );
 389
 390     var_Create( p_this, "dshow-fps", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
 391     var_Create( p_this, "dshow-tuner-channel",
 392                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 393     var_Create( p_this, "dshow-tuner-country",
 394                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 395     var_Create( p_this, "dshow-tuner-input",
 396                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 397
 398     var_Create( p_this, "dshow-amtuner-mode",
 399                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 400
 401     var_Create( p_this, "dshow-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 402
 403     var_Create( p_this, "dshow-video-input", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 404     var_Create( p_this, "dshow-audio-input", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 405     var_Create( p_this, "dshow-video-output", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 406     var_Create( p_this, "dshow-audio-output", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 407
 408     /* Initialize OLE/COM */
 409     CoInitialize( 0 );
 410
 411     /* Initialize some data */
 412     p_sys->i_streams = 0;
 413     p_sys->pp_streams = 0;
 414     p_sys->i_width = i_width;
 415     p_sys->i_height = i_height;
 416     p_sys->i_chroma = i_chroma;
 417
 418     p_sys->p_graph = NULL;
 419     p_sys->p_capture_graph_builder2 = NULL;
 420     p_sys->p_control = NULL;
 421
 422     vlc_mutex_init( &p_sys->lock );
 423     vlc_cond_init( p_this, &p_sys->wait );
 424
 425     /* Build directshow graph */
 426     CreateDirectShowGraph( p_sys );
 427
 428     if( OpenDevice( p_this, p_sys, vdevname, 0 ) != VLC_SUCCESS )
 429     {
 430         msg_Err( p_this, "can't open video");
 431     }
 432     else
 433     {
 434         /* Check if we can handle the demuxing ourselves or need to spawn
 435          * a demuxer module */
 436         dshow_stream_t *p_stream = p_sys->pp_streams[p_sys->i_streams-1];
 437
 438         if( p_stream->mt.majortype == MEDIATYPE_Video )
 439         {
 440             if( /* Raw DV stream */
 441                 p_stream->i_fourcc == VLC_FOURCC('d','v','s','l') ||
 442                 p_stream->i_fourcc == VLC_FOURCC('d','v','s','d') ||
 443                 p_stream->i_fourcc == VLC_FOURCC('d','v','h','d') ||
 444                 /* Raw MPEG video stream */
 445                 p_stream->i_fourcc == VLC_FOURCC('m','p','2','v') )
 446             {
 447                 b_audio = false;
 448
 449                 if( b_access_demux )
 450                 {
 451                     /* Let the access (only) take care of that */
 452                     return VLC_EGENERIC;
 453                 }
 454             }
 455         }
 456
 457         if( p_stream->mt.majortype == MEDIATYPE_Stream )
 458         {
 459             b_audio = false;
 460
 461             if( b_access_demux )
 462             {
 463                 /* Let the access (only) take care of that */
 464                 return VLC_EGENERIC;
 465             }
 466
 467             var_Get( p_this, "dshow-tuner", &val );
 468             if( val.b_bool )
 469             {
 470                 /* FIXME: we do MEDIATYPE_Stream here so we don't do
 471                  * it twice. */
 472                 ShowTunerProperties( p_this, p_sys->p_capture_graph_builder2,
 473                                      p_stream->p_device_filter, 0 );
 474             }
 475         }
 476     }
 477
 478     if( b_audio && OpenDevice( p_this, p_sys, adevname, 1 ) != VLC_SUCCESS )
 479     {
 480         msg_Err( p_this, "can't open audio");
 481     }
 482
 483     for( i = p_sys->i_crossbar_route_depth-1; i >= 0 ; --i )
 484     {
 485             var_Get( p_this, "dshow-video-input", &val );
 486             if( val.i_int >= 0 )
 487                     p_sys->crossbar_routes[i].VideoInputIndex=val.i_int;
 488             var_Get( p_this, "dshow-video-output", &val );
 489             if( val.i_int >= 0 )
 490                     p_sys->crossbar_routes[i].VideoOutputIndex=val.i_int;
 491             var_Get( p_this, "dshow-audio-input", &val );
 492             if( val.i_int >= 0 )
 493                     p_sys->crossbar_routes[i].AudioInputIndex=val.i_int;
 494             var_Get( p_this, "dshow-audio-output", &val );
 495             if( val.i_int >= 0 )
 496                     p_sys->crossbar_routes[i].AudioOutputIndex=val.i_int;
 497
 498         IAMCrossbar *pXbar = p_sys->crossbar_routes[i].pXbar;
 499         LONG VideoInputIndex = p_sys->crossbar_routes[i].VideoInputIndex;
 500         LONG VideoOutputIndex = p_sys->crossbar_routes[i].VideoOutputIndex;
 501         LONG AudioInputIndex = p_sys->crossbar_routes[i].AudioInputIndex;
 502         LONG AudioOutputIndex = p_sys->crossbar_routes[i].AudioOutputIndex;
 503
 504         if( SUCCEEDED(pXbar->Route(VideoOutputIndex, VideoInputIndex)) )
 505         {
 506             msg_Dbg( p_this, "crossbar at depth %d, routed video "
 507                      "output %ld to video input %ld", i, VideoOutputIndex,
 508                      VideoInputIndex );
 509
 510             if( AudioOutputIndex != -1 && AudioInputIndex != -1 )
 511             {
 512                 if( SUCCEEDED( pXbar->Route(AudioOutputIndex,
 513                                             AudioInputIndex)) )
 514                 {
 515                     msg_Dbg(p_this, "crossbar at depth %d, routed audio "
 516                             "output %ld to audio input %ld", i,
 517                             AudioOutputIndex, AudioInputIndex );
 518                 }
 519             }
 520         }
 521     }
 522
 523     /*
 524     ** Show properties pages from other filters in graph
 525     */
 526     var_Get( p_this, "dshow-config", &val );
 527     if( val.b_bool )
 528     {
 529         for( i = p_sys->i_crossbar_route_depth-1; i >= 0 ; --i )
 530         {
 531             IAMCrossbar *pXbar = p_sys->crossbar_routes[i].pXbar;
 532             IBaseFilter *p_XF;
 533
 534             if( SUCCEEDED( pXbar->QueryInterface( IID_IBaseFilter,
 535                                                   (void **)&p_XF ) ) )
 536             {
 537                 ShowPropertyPage( p_XF );
 538                 p_XF->Release();
 539             }
 540         }
 541     }
 542
 543     /* Initialize some data */
 544     p_sys->i_current_stream = 0;
 545
 546     if( !p_sys->i_streams ) return VLC_EGENERIC;
 547
 548     return VLC_SUCCESS;
 549 }
 550
 551 /*****************************************************************************
 552  * DemuxOpen: open direct show device as an access_demux module
 553  *****************************************************************************/
 554 static int DemuxOpen( vlc_object_t *p_this )
 555 {
 556     demux_t      *p_demux = (demux_t *)p_this;
 557     access_sys_t *p_sys;
 558     int i;
 559
 560     p_sys = (access_sys_t *)malloc( sizeof( access_sys_t ) );
 561     memset( p_sys, 0, sizeof( access_sys_t ) );
 562     p_demux->p_sys = (demux_sys_t *)p_sys;
 563
 564     if( CommonOpen( p_this, p_sys, true ) != VLC_SUCCESS )
 565     {
 566         CommonClose( p_this, p_sys );
 567         return VLC_EGENERIC;
 568     }
 569
 570     /* Everything is ready. Let's rock baby */
 571     msg_Dbg( p_this, "Playing...");
 572     p_sys->p_control->Run();
 573
 574     p_demux->pf_demux   = Demux;
 575     p_demux->pf_control = DemuxControl;
 576     p_demux->info.i_update = 0;
 577     p_demux->info.i_title = 0;
 578     p_demux->info.i_seekpoint = 0;
 579
 580     for( i = 0; i < p_sys->i_streams; i++ )
 581     {
 582         dshow_stream_t *p_stream = p_sys->pp_streams[i];
 583         es_format_t fmt;
 584
 585         if( p_stream->mt.majortype == MEDIATYPE_Video )
 586         {
 587             es_format_Init( &fmt, VIDEO_ES, p_stream->i_fourcc );
 588
 589             fmt.video.i_width  = p_stream->header.video.bmiHeader.biWidth;
 590             fmt.video.i_height = p_stream->header.video.bmiHeader.biHeight;
 591             fmt.video.i_aspect = 4 * VOUT_ASPECT_FACTOR / 3;
 592
 593             if( !p_stream->header.video.bmiHeader.biCompression )
 594             {
 595                 /* RGB DIB are coded from bottom to top */
 596                 fmt.video.i_height = (unsigned int)(-(int)fmt.video.i_height);
 597             }
 598
 599             /* Setup rgb mask for RGB formats */
 600             if( p_stream->i_fourcc == VLC_FOURCC('R','V','2','4') )
 601             {
 602                 /* This is in BGR format */
 603                 fmt.video.i_bmask = 0x00ff0000;
 604                 fmt.video.i_gmask = 0x0000ff00;
 605                 fmt.video.i_rmask = 0x000000ff;
 606             }
 607
 608             if( p_stream->header.video.AvgTimePerFrame )
 609             {
 610                 fmt.video.i_frame_rate = 10000000;
 611                 fmt.video.i_frame_rate_base =
 612                     p_stream->header.video.AvgTimePerFrame;
 613             }
 614         }
 615         else if( p_stream->mt.majortype == MEDIATYPE_Audio )
 616         {
 617             es_format_Init( &fmt, AUDIO_ES, p_stream->i_fourcc );
 618
 619             fmt.audio.i_channels = p_stream->header.audio.nChannels;
 620             fmt.audio.i_rate = p_stream->header.audio.nSamplesPerSec;
 621             fmt.audio.i_bitspersample = p_stream->header.audio.wBitsPerSample;
 622             fmt.audio.i_blockalign = fmt.audio.i_channels *
 623                 fmt.audio.i_bitspersample / 8;
 624             fmt.i_bitrate = fmt.audio.i_channels * fmt.audio.i_rate *
 625                 fmt.audio.i_bitspersample;
 626         }
 627
 628         p_stream->p_es = es_out_Add( p_demux->out, &fmt );
 629     }
 630
 631     return VLC_SUCCESS;
 632 }
 633
 634 /*****************************************************************************
 635  * AccessOpen: open direct show device as an access module
 636  *****************************************************************************/
 637 static int AccessOpen( vlc_object_t *p_this )
 638 {
 639     access_t     *p_access = (access_t*)p_this;
 640     access_sys_t *p_sys;
 641
 642     p_access->p_sys = p_sys = (access_sys_t *)malloc( sizeof( access_sys_t ) );
 643     memset( p_sys, 0, sizeof( access_sys_t ) );
 644
 645     if( CommonOpen( p_this, p_sys, false ) != VLC_SUCCESS )
 646     {
 647         CommonClose( p_this, p_sys );
 648         return VLC_EGENERIC;
 649     }
 650
 651     dshow_stream_t *p_stream = p_sys->pp_streams[0];
 652
 653     /* Check if we need to force demuxers */
 654     if( !p_access->psz_demux || !*p_access->psz_demux )
 655     {
 656         if( p_stream->i_fourcc == VLC_FOURCC('d','v','s','l') ||
 657             p_stream->i_fourcc == VLC_FOURCC('d','v','s','d') ||
 658             p_stream->i_fourcc == VLC_FOURCC('d','v','h','d') )
 659         {
 660             free( p_access->psz_demux );
 661             p_access->psz_demux = strdup( "rawdv" );
 662         }
 663         else if( p_stream->i_fourcc == VLC_FOURCC('m','p','2','v') )
 664         {
 665             free( p_access->psz_demux );
 666             p_access->psz_demux = strdup( "mpgv" );
 667         }
 668     }
 669
 670     /* Setup Access */
 671     p_access->pf_read = NULL;
 672     p_access->pf_block = ReadCompressed;
 673     p_access->pf_control = AccessControl;
 674     p_access->pf_seek = NULL;
 675     p_access->info.i_update = 0;
 676     p_access->info.i_size = 0;
 677     p_access->info.i_pos = 0;
 678     p_access->info.b_eof = false;
 679     p_access->info.i_title = 0;
 680     p_access->info.i_seekpoint = 0;
 681     p_access->p_sys = p_sys;
 682
 683     /* Everything is ready. Let's rock baby */
 684     msg_Dbg( p_this, "Playing...");
 685     p_sys->p_control->Run();
 686
 687     return VLC_SUCCESS;
 688 }
 689
 690 /*****************************************************************************
 691  * CommonClose: close device
 692  *****************************************************************************/
 693 static void CommonClose( vlc_object_t *p_this, access_sys_t *p_sys )
 694 {
 695     msg_Dbg( p_this, "releasing DirectShow");
 696
 697     DeleteDirectShowGraph( p_sys );
 698
 699     /* Uninitialize OLE/COM */
 700     CoUninitialize();
 701
 702     for( int i = 0; i < p_sys->i_streams; i++ ) delete p_sys->pp_streams[i];
 703     if( p_sys->i_streams ) free( p_sys->pp_streams );
 704
 705     vlc_mutex_destroy( &p_sys->lock );
 706     vlc_cond_destroy( &p_sys->wait );
 707
 708     free( p_sys );
 709 }
 710
 711 /*****************************************************************************
 712  * AccessClose: close device
 713  *****************************************************************************/
 714 static void AccessClose( vlc_object_t *p_this )
 715 {
 716     access_t     *p_access = (access_t *)p_this;
 717     access_sys_t *p_sys    = p_access->p_sys;
 718
 719     /* Stop capturing stuff */
 720     p_sys->p_control->Stop();
 721
 722     CommonClose( p_this, p_sys );
 723 }
 724
 725 /*****************************************************************************
 726  * DemuxClose: close device
 727  *****************************************************************************/
 728 static void DemuxClose( vlc_object_t *p_this )
 729 {
 730     demux_t      *p_demux = (demux_t *)p_this;
 731     access_sys_t *p_sys   = (access_sys_t *)p_demux->p_sys;
 732
 733     /* Stop capturing stuff */
 734     p_sys->p_control->Stop();
 735
 736     CommonClose( p_this, p_sys );
 737 }
 738
 739 /****************************************************************************
 740  * ConnectFilters
 741  ****************************************************************************/
 742 static bool ConnectFilters( vlc_object_t *p_this, access_sys_t *p_sys,
 743                             IBaseFilter *p_filter,
 744                             CaptureFilter *p_capture_filter )
 745 {
 746     CapturePin *p_input_pin = p_capture_filter->CustomGetPin();
 747
 748     AM_MEDIA_TYPE mediaType = p_input_pin->CustomGetMediaType();
 749
 750     if( p_sys->p_capture_graph_builder2 )
 751     {
 752         if( FAILED(p_sys->p_capture_graph_builder2->
 753                 RenderStream( &PIN_CATEGORY_CAPTURE, &mediaType.majortype,
 754                               p_filter, 0, (IBaseFilter *)p_capture_filter )) )
 755         {
 756             return false;
 757         }
 758
 759         // Sort out all the possible video inputs
 760         // The class needs to be given the capture filters ANALOGVIDEO input pin
 761         IEnumPins *pins = 0;
 762         if( ( mediaType.majortype == MEDIATYPE_Video ||
 763               mediaType.majortype == MEDIATYPE_Stream ) &&
 764             SUCCEEDED(p_filter->EnumPins(&pins)) )
 765         {
 766             IPin        *pP = 0;
 767             ULONG        n;
 768             PIN_INFO     pinInfo;
 769             BOOL         Found = FALSE;
 770             IKsPropertySet *pKs=0;
 771             GUID guid;
 772             DWORD dw;
 773
 774             while( !Found && ( S_OK == pins->Next(1, &pP, &n) ) )
 775             {
 776                 if( S_OK == pP->QueryPinInfo(&pinInfo) )
 777                 {
 778                     // is this pin an ANALOGVIDEOIN input pin?
 779                     if( pinInfo.dir == PINDIR_INPUT &&
 780                         pP->QueryInterface( IID_IKsPropertySet,
 781                                             (void **)&pKs ) == S_OK )
 782                     {
 783                         if( pKs->Get( AMPROPSETID_Pin,
 784                                       AMPROPERTY_PIN_CATEGORY, NULL, 0,
 785                                       &guid, sizeof(GUID), &dw ) == S_OK )
 786                         {
 787                             if( guid == PIN_CATEGORY_ANALOGVIDEOIN )
 788                             {
 789                                 // recursively search crossbar routes
 790                                 FindCrossbarRoutes( p_this, p_sys, pP, 0 );
 791                                 // found it
 792                                 Found = TRUE;
 793                             }
 794                         }
 795                         pKs->Release();
 796                     }
 797                     pinInfo.pFilter->Release();
 798                 }
 799                 pP->Release();
 800             }
 801             pins->Release();
 802         }
 803         return true;
 804     }
 805     else
 806     {
 807         IEnumPins *p_enumpins;
 808         IPin *p_pin;
 809
 810         if( S_OK != p_filter->EnumPins( &p_enumpins ) ) return false;
 811
 812         while( S_OK == p_enumpins->Next( 1, &p_pin, NULL ) )
 813         {
 814             PIN_DIRECTION pin_dir;
 815             p_pin->QueryDirection( &pin_dir );
 816
 817             if( pin_dir == PINDIR_OUTPUT &&
 818                 p_sys->p_graph->ConnectDirect( p_pin, (IPin *)p_input_pin,
 819                                                0 ) == S_OK )
 820             {
 821                 p_pin->Release();
 822                 p_enumpins->Release();
 823                 return true;
 824             }
 825             p_pin->Release();
 826         }
 827
 828         p_enumpins->Release();
 829         return false;
 830     }
 831 }
 832
 833 /*
 834  * get fourcc priority from arbritary preference, the higher the better
 835  */
 836 static int GetFourCCPriority( int i_fourcc )
 837 {
 838     switch( i_fourcc )
 839     {
 840     case VLC_FOURCC('I','4','2','0'):
 841     case VLC_FOURCC('f','l','3','2'):
 842         return 9;
 843     case VLC_FOURCC('Y','V','1','2'):
 844     case VLC_FOURCC('a','r','a','w'):
 845         return 8;
 846     case VLC_FOURCC('R','V','2','4'):
 847         return 7;
 848     case VLC_FOURCC('Y','U','Y','2'):
 849     case VLC_FOURCC('R','V','3','2'):
 850     case VLC_FOURCC('R','G','B','A'):
 851         return 6;
 852     }
 853
 854     return 0;
 855 }
 856
 857 #define MAX_MEDIA_TYPES 32
 858
 859 static int OpenDevice( vlc_object_t *p_this, access_sys_t *p_sys,
 860                        string devicename, bool b_audio )
 861 {
 862     /* See if device is already opened */
 863     for( int i = 0; i < p_sys->i_streams; i++ )
 864     {
 865         if( devicename.size() &&
 866             p_sys->pp_streams[i]->devicename == devicename )
 867         {
 868             /* Already opened */
 869             return VLC_SUCCESS;
 870         }
 871     }
 872
 873     list<string> list_devices;
 874
 875     /* Enumerate devices and display their names */
 876     FindCaptureDevice( p_this, NULL, &list_devices, b_audio );
 877
 878     if( !list_devices.size() )
 879         return VLC_EGENERIC;
 880
 881     list<string>::iterator iter;
 882     for( iter = list_devices.begin(); iter != list_devices.end(); iter++ )
 883         msg_Dbg( p_this, "found device: %s", iter->c_str() );
 884
 885     /* If no device name was specified, pick the 1st one */
 886     if( devicename.size() == 0 )
 887     {
 888         devicename = *list_devices.begin();
 889     }
 890
 891     // Use the system device enumerator and class enumerator to find
 892     // a capture/preview device, such as a desktop USB video camera.
 893     IBaseFilter *p_device_filter =
 894         FindCaptureDevice( p_this, &devicename, 0, b_audio );
 895     if( p_device_filter )
 896         msg_Dbg( p_this, "using device: %s", devicename.c_str() );
 897     else
 898     {
 899         msg_Err( p_this, "can't use device: %s, unsupported device type",
 900                  devicename.c_str() );
 901         intf_UserFatal( p_this, false, _("Capturing failed"),
 902                         _("VLC cannot use the device \"%s\", because its "
 903                           "type is not supported.") );
 904         return VLC_EGENERIC;
 905     }
 906
 907     // Retreive acceptable media types supported by device
 908     AM_MEDIA_TYPE media_types[MAX_MEDIA_TYPES];
 909     size_t media_count =
 910         EnumDeviceCaps( p_this, p_device_filter, b_audio ? 0 : p_sys->i_chroma,
 911                         p_sys->i_width, p_sys->i_height,
 912                         0, 0, 0, media_types, MAX_MEDIA_TYPES );
 913
 914     AM_MEDIA_TYPE *mt = NULL;
 915
 916     if( media_count > 0 )
 917     {
 918         mt = (AM_MEDIA_TYPE *)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * media_count);
 919
 920         // Order and copy returned media types according to arbitrary
 921         // fourcc priority
 922         for( size_t c = 0; c < media_count; c++ )
 923         {
 924             int slot_priority =
 925                 GetFourCCPriority(GetFourCCFromMediaType(media_types[c]));
 926             size_t slot_copy = c;
 927             for( size_t d = c+1; d < media_count; d++ )
 928             {
 929                 int priority =
 930                     GetFourCCPriority(GetFourCCFromMediaType(media_types[d]));
 931                 if( priority > slot_priority )
 932                 {
 933                     slot_priority = priority;
 934                     slot_copy = d;
 935                 }
 936             }
 937             if( slot_copy != c )
 938             {
 939                 mt[c] = media_types[slot_copy];
 940                 media_types[slot_copy] = media_types[c];
 941             }
 942             else
 943             {
 944                 mt[c] = media_types[c];
 945             }
 946         }
 947     }
 948     else {
 949         /* capture device */
 950         msg_Err( p_this, "capture device '%s' does not support required parameters !", devicename.c_str() );
 951         intf_UserFatal( p_this, false, _("Capturing failed"),
 952                         _("The capture device \"%s\" does not support the "
 953                           "required parameters."), devicename.c_str() );
 954         p_device_filter->Release();
 955         return VLC_EGENERIC;
 956     }
 957
 958     /* Create and add our capture filter */
 959     CaptureFilter *p_capture_filter =
 960         new CaptureFilter( p_this, p_sys, mt, media_count );
 961     p_sys->p_graph->AddFilter( p_capture_filter, 0 );
 962
 963     /* Add the device filter to the graph (seems necessary with VfW before
 964      * accessing pin attributes). */
 965     p_sys->p_graph->AddFilter( p_device_filter, 0 );
 966
 967     /* Attempt to connect one of this device's capture output pins */
 968     msg_Dbg( p_this, "connecting filters" );
 969     if( ConnectFilters( p_this, p_sys, p_device_filter, p_capture_filter ) )
 970     {
 971         /* Success */
 972         msg_Dbg( p_this, "filters connected successfully !" );
 973
 974         dshow_stream_t dshow_stream;
 975         dshow_stream.b_pts = false;
 976         dshow_stream.p_es = 0;
 977         dshow_stream.mt =
 978             p_capture_filter->CustomGetPin()->CustomGetMediaType();
 979
 980         /* Show Device properties. Done here so the VLC stream is setup with
 981          * the proper parameters. */
 982         vlc_value_t val;
 983         var_Get( p_this, "dshow-config", &val );
 984         if( val.b_bool )
 985         {
 986             ShowDeviceProperties( p_this, p_sys->p_capture_graph_builder2,
 987                                   p_device_filter, b_audio );
 988         }
 989
 990         ConfigTuner( p_this, p_sys->p_capture_graph_builder2,
 991                      p_device_filter );
 992
 993         var_Get( p_this, "dshow-tuner", &val );
 994         if( val.b_bool && dshow_stream.mt.majortype != MEDIATYPE_Stream )
 995         {
 996             /* FIXME: we do MEDIATYPE_Stream later so we don't do it twice. */
 997             ShowTunerProperties( p_this, p_sys->p_capture_graph_builder2,
 998                                  p_device_filter, b_audio );
 999         }
1000
1001         dshow_stream.mt =
1002             p_capture_filter->CustomGetPin()->CustomGetMediaType();
1003
1004         dshow_stream.i_fourcc = GetFourCCFromMediaType( dshow_stream.mt );
1005         if( dshow_stream.i_fourcc )
1006         {
1007             if( dshow_stream.mt.majortype == MEDIATYPE_Video )
1008             {
1009                 dshow_stream.header.video =
1010                     *(VIDEOINFOHEADER *)dshow_stream.mt.pbFormat;
1011                 msg_Dbg( p_this, "MEDIATYPE_Video" );
1012                 msg_Dbg( p_this, "selected video pin accepts format: %4.4s",
1013                          (char *)&dshow_stream.i_fourcc);
1014             }
1015             else if( dshow_stream.mt.majortype == MEDIATYPE_Audio )
1016             {
1017                 dshow_stream.header.audio =
1018                     *(WAVEFORMATEX *)dshow_stream.mt.pbFormat;
1019                 msg_Dbg( p_this, "MEDIATYPE_Audio" );
1020                 msg_Dbg( p_this, "selected audio pin accepts format: %4.4s",
1021                          (char *)&dshow_stream.i_fourcc);
1022             }
1023             else if( dshow_stream.mt.majortype == MEDIATYPE_Stream )
1024             {
1025                 msg_Dbg( p_this, "MEDIATYPE_Stream" );
1026                 msg_Dbg( p_this, "selected stream pin accepts format: %4.4s",
1027                          (char *)&dshow_stream.i_fourcc);
1028             }
1029             else
1030             {
1031                 msg_Dbg( p_this, "unknown stream majortype" );
1032                 goto fail;
1033             }
1034
1035             /* Add directshow elementary stream to our list */
1036             dshow_stream.p_device_filter = p_device_filter;
1037             dshow_stream.p_capture_filter = p_capture_filter;
1038
1039             p_sys->pp_streams = (dshow_stream_t **)realloc( p_sys->pp_streams,
1040                 sizeof(dshow_stream_t *) * (p_sys->i_streams + 1) );
1041             p_sys->pp_streams[p_sys->i_streams] = new dshow_stream_t;
1042             *p_sys->pp_streams[p_sys->i_streams++] = dshow_stream;
1043
1044             return VLC_SUCCESS;
1045         }
1046     }
1047
1048  fail:
1049     /* Remove filters from graph */
1050     p_sys->p_graph->RemoveFilter( p_device_filter );
1051     p_sys->p_graph->RemoveFilter( p_capture_filter );
1052
1053     /* Release objects */
1054     p_device_filter->Release();
1055     p_capture_filter->Release();
1056
1057     return VLC_EGENERIC;
1058 }
1059
1060 static IBaseFilter *
1061 FindCaptureDevice( vlc_object_t *p_this, string *p_devicename,
1062                    list<string> *p_listdevices, bool b_audio )
1063 {
1064     IBaseFilter *p_base_filter = NULL;
1065     IMoniker *p_moniker = NULL;
1066     ULONG i_fetched;
1067     HRESULT hr;
1068     list<string> devicelist;
1069
1070     /* Create the system device enumerator */
1071     ICreateDevEnum *p_dev_enum = NULL;
1072
1073     hr = CoCreateInstance( CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
1074                            IID_ICreateDevEnum, (void **)&p_dev_enum );
1075     if( FAILED(hr) )
1076     {
1077         msg_Err( p_this, "failed to create the device enumerator (0x%lx)", hr);
1078         return NULL;
1079     }
1080
1081     /* Create an enumerator for the video capture devices */
1082     IEnumMoniker *p_class_enum = NULL;
1083     if( !b_audio )
1084         hr = p_dev_enum->CreateClassEnumerator( CLSID_VideoInputDeviceCategory,
1085                                                 &p_class_enum, 0 );
1086     else
1087         hr = p_dev_enum->CreateClassEnumerator( CLSID_AudioInputDeviceCategory,
1088                                                 &p_class_enum, 0 );
1089     p_dev_enum->Release();
1090     if( FAILED(hr) )
1091     {
1092         msg_Err( p_this, "failed to create the class enumerator (0x%lx)", hr );
1093         return NULL;
1094     }
1095
1096     /* If there are no enumerators for the requested type, then
1097      * CreateClassEnumerator will succeed, but p_class_enum will be NULL */
1098     if( p_class_enum == NULL )
1099     {
1100         msg_Err( p_this, "no capture device was detected" );
1101         return NULL;
1102     }
1103
1104     /* Enumerate the devices */
1105
1106     /* Note that if the Next() call succeeds but there are no monikers,
1107      * it will return S_FALSE (which is not a failure). Therefore, we check
1108      * that the return code is S_OK instead of using SUCCEEDED() macro. */
1109
1110     while( p_class_enum->Next( 1, &p_moniker, &i_fetched ) == S_OK )
1111     {
1112         /* Getting the property page to get the device name */
1113         IPropertyBag *p_bag;
1114         hr = p_moniker->BindToStorage( 0, 0, IID_IPropertyBag,
1115                                        (void **)&p_bag );
1116         if( SUCCEEDED(hr) )
1117         {
1118             VARIANT var;
1119             var.vt = VT_BSTR;
1120             hr = p_bag->Read( L"FriendlyName", &var, NULL );
1121             p_bag->Release();
1122             if( SUCCEEDED(hr) )
1123             {
1124                 int i_convert = WideCharToMultiByte(CP_ACP, 0, var.bstrVal,
1125                         SysStringLen(var.bstrVal), NULL, 0, NULL, NULL);
1126                 char *p_buf = (char *)alloca( i_convert+1 ); p_buf[0] = 0;
1127                 WideCharToMultiByte( CP_ACP, 0, var.bstrVal,
1128                         SysStringLen(var.bstrVal), p_buf, i_convert, NULL, NULL );
1129                 SysFreeString(var.bstrVal);
1130                 p_buf[i_convert] = '\0';
1131
1132         string devname = string(p_buf);
1133
1134         int dup = 0;
1135         /* find out if this name is already used by a previously found device */
1136         list<string>::const_iterator iter = devicelist.begin();
1137         list<string>::const_iterator end = devicelist.end();
1138         while ( iter != end )
1139         {
1140             if( 0 == (*iter).compare(0, devname.size(), devname) )
1141             ++dup;
1142             ++iter;
1143         }
1144         if( dup )
1145         {
1146             /* we have a duplicate device name, append a sequence number to name
1147                to provive a unique list back to the user */
1148             char seq[16];
1149             sprintf(seq, " #%d", dup);
1150             devname.append(seq);
1151         }
1152         devicelist.push_back( devname );
1153
1154                 if( p_devicename && *p_devicename == devname )
1155                 {
1156                     /* Bind Moniker to a filter object */
1157                     hr = p_moniker->BindToObject( 0, 0, IID_IBaseFilter,
1158                                                   (void **)&p_base_filter );
1159                     if( FAILED(hr) )
1160                     {
1161                         msg_Err( p_this, "couldn't bind moniker to filter "
1162                                  "object (0x%lx)", hr );
1163                         p_moniker->Release();
1164                         p_class_enum->Release();
1165                         return NULL;
1166                     }
1167                     p_moniker->Release();
1168                     p_class_enum->Release();
1169                     return p_base_filter;
1170                 }
1171             }
1172         }
1173
1174         p_moniker->Release();
1175     }
1176
1177     p_class_enum->Release();
1178
1179     if( p_listdevices ) {
1180     devicelist.sort();
1181     *p_listdevices = devicelist;
1182     }
1183     return NULL;
1184 }
1185
1186 static size_t EnumDeviceCaps( vlc_object_t *p_this, IBaseFilter *p_filter,
1187                               int i_fourcc, int i_width, int i_height,
1188                               int i_channels, int i_samplespersec,
1189                               int i_bitspersample, AM_MEDIA_TYPE *mt,
1190                               size_t mt_max )
1191 {
1192     IEnumPins *p_enumpins;
1193     IPin *p_output_pin;
1194     IEnumMediaTypes *p_enummt;
1195     size_t mt_count = 0;
1196
1197     LONGLONG i_AvgTimePerFrame = 0;
1198     float r_fps = var_GetFloat( p_this, "dshow-fps" );
1199     if( r_fps )
1200         i_AvgTimePerFrame = 10000000000LL/(LONGLONG)(r_fps*1000.0f);
1201
1202     if( FAILED(p_filter->EnumPins( &p_enumpins )) )
1203     {
1204         msg_Dbg( p_this, "EnumDeviceCaps failed: no pin enumeration !");
1205         return 0;
1206     }
1207
1208     while( S_OK == p_enumpins->Next( 1, &p_output_pin, NULL ) )
1209     {
1210         PIN_INFO info;
1211
1212         if( S_OK == p_output_pin->QueryPinInfo( &info ) )
1213         {
1214             msg_Dbg( p_this, "EnumDeviceCaps: %s pin: %S",
1215                      info.dir == PINDIR_INPUT ? "input" : "output",
1216                      info.achName );
1217             if( info.pFilter ) info.pFilter->Release();
1218         }
1219
1220         p_output_pin->Release();
1221     }
1222
1223     p_enumpins->Reset();
1224
1225     while( !mt_count && p_enumpins->Next( 1, &p_output_pin, NULL ) == S_OK )
1226     {
1227         PIN_INFO info;
1228
1229         if( S_OK == p_output_pin->QueryPinInfo( &info ) )
1230         {
1231             if( info.pFilter ) info.pFilter->Release();
1232             if( info.dir == PINDIR_INPUT )
1233             {
1234                 p_output_pin->Release();
1235                 continue;
1236             }
1237             msg_Dbg( p_this, "EnumDeviceCaps: trying pin %S", info.achName );
1238         }
1239
1240         AM_MEDIA_TYPE *p_mt;
1241
1242         /*
1243         ** Configure pin with a default compatible media if possible
1244         */
1245
1246         IAMStreamConfig *pSC;
1247         if( SUCCEEDED(p_output_pin->QueryInterface( IID_IAMStreamConfig,
1248                                             (void **)&pSC )) )
1249         {
1250             int piCount, piSize;
1251             if( SUCCEEDED(pSC->GetNumberOfCapabilities(&piCount, &piSize)) )
1252             {
1253                 BYTE *pSCC= (BYTE *)CoTaskMemAlloc(piSize);
1254                 if( NULL != pSCC )
1255                 {
1256                     int i_priority = -1;
1257                     for( int i=0; i<piCount; ++i )
1258                     {
1259                         if( SUCCEEDED(pSC->GetStreamCaps(i, &p_mt, pSCC)) )
1260                         {
1261                             int i_current_fourcc = GetFourCCFromMediaType( *p_mt );
1262                             int i_current_priority = GetFourCCPriority(i_current_fourcc);
1263
1264                             if( (i_fourcc && (i_current_fourcc != i_fourcc))
1265                              || (i_priority > i_current_priority) )
1266                             {
1267                                 // unwanted chroma, try next media type
1268                                 FreeMediaType( *p_mt );
1269                                 CoTaskMemFree( (PVOID)p_mt );
1270                                 continue;
1271                             }
1272
1273                             if( MEDIATYPE_Video == p_mt->majortype
1274                                     && FORMAT_VideoInfo == p_mt->formattype )
1275                             {
1276                                 VIDEO_STREAM_CONFIG_CAPS *pVSCC = reinterpret_cast<VIDEO_STREAM_CONFIG_CAPS*>(pSCC);
1277                                 VIDEOINFOHEADER *pVih = reinterpret_cast<VIDEOINFOHEADER*>(p_mt->pbFormat);
1278
1279                                 if( i_AvgTimePerFrame )
1280                                 {
1281                                     if( pVSCC->MinFrameInterval > i_AvgTimePerFrame
1282                                       || i_AvgTimePerFrame > pVSCC->MaxFrameInterval )
1283                                     {
1284                                         // required frame rate not compatible, try next media type
1285                                         FreeMediaType( *p_mt );
1286                                         CoTaskMemFree( (PVOID)p_mt );
1287                                         continue;
1288                                     }
1289                                     pVih->AvgTimePerFrame = i_AvgTimePerFrame;
1290                                 }
1291
1292                                 if( i_width )
1293                                 {
1294                                     if( i_width % pVSCC->OutputGranularityX
1295                                      || pVSCC->MinOutputSize.cx > i_width
1296                                      || i_width > pVSCC->MaxOutputSize.cx )
1297                                     {
1298                                         // required width not compatible, try next media type
1299                                         FreeMediaType( *p_mt );
1300                                         CoTaskMemFree( (PVOID)p_mt );
1301                                         continue;
1302                                     }
1303                                     pVih->bmiHeader.biWidth = i_width;
1304                                 }
1305
1306                                 if( i_height )
1307                                 {
1308                                     if( i_height % pVSCC->OutputGranularityY
1309                                      || pVSCC->MinOutputSize.cy > i_height
1310                                      || i_height > pVSCC->MaxOutputSize.cy )
1311                                     {
1312                                         // required height not compatible, try next media type
1313                                         FreeMediaType( *p_mt );
1314                                         CoTaskMemFree( (PVOID)p_mt );
1315                                         continue;
1316                                     }
1317                                     pVih->bmiHeader.biHeight = i_height;
1318                                 }
1319
1320                                 // Set the sample size and image size.
1321                                 // (Round the image width up to a DWORD boundary.)
1322                                 p_mt->lSampleSize = pVih->bmiHeader.biSizeImage =
1323                                     ((pVih->bmiHeader.biWidth + 3) & ~3) *
1324                                     pVih->bmiHeader.biHeight * (pVih->bmiHeader.biBitCount>>3);
1325
1326                                 // no cropping, use full video input buffer
1327                                 memset(&(pVih->rcSource), 0, sizeof(RECT));
1328                                 memset(&(pVih->rcTarget), 0, sizeof(RECT));
1329
1330                                 // select this format as default
1331                                 if( SUCCEEDED( pSC->SetFormat(p_mt) ) )
1332                                 {
1333                                     i_priority = i_current_priority;
1334                                     if( i_fourcc )
1335                                         // no need to check any more media types
1336                                         i = piCount;
1337                                 }
1338                             }
1339                             else if( p_mt->majortype == MEDIATYPE_Audio
1340                                     && p_mt->formattype == FORMAT_WaveFormatEx )
1341                             {
1342                                 AUDIO_STREAM_CONFIG_CAPS *pASCC = reinterpret_cast<AUDIO_STREAM_CONFIG_CAPS*>(pSCC);
1343                                 WAVEFORMATEX *pWfx = reinterpret_cast<WAVEFORMATEX*>(p_mt->pbFormat);
1344
1345                                 if( i_current_fourcc && (WAVE_FORMAT_PCM == pWfx->wFormatTag) )
1346                                 {
1347                                     int val = i_channels;
1348                                     if( ! val )
1349                                         val = 2;
1350
1351                                     if( val % pASCC->ChannelsGranularity
1352                                      || (unsigned int)val < pASCC->MinimumChannels
1353                                      || (unsigned int)val > pASCC->MaximumChannels )
1354                                     {
1355                                         // required number channels not available, try next media type
1356                                         FreeMediaType( *p_mt );
1357                                         CoTaskMemFree( (PVOID)p_mt );
1358                                         continue;
1359                                     }
1360                                     pWfx->nChannels = val;
1361
1362                                     val = i_samplespersec;
1363                                     if( ! val )
1364                                         val = 44100;
1365
1366                                     if( val % pASCC->SampleFrequencyGranularity
1367                                      || (unsigned int)val < pASCC->MinimumSampleFrequency
1368                                      || (unsigned int)val > pASCC->MaximumSampleFrequency )
1369                                     {
1370                                         // required sampling rate not available, try next media type
1371                                         FreeMediaType( *p_mt );
1372                                         CoTaskMemFree( (PVOID)p_mt );
1373                                         continue;
1374                                     }
1375                                     pWfx->nSamplesPerSec = val;
1376
1377                                     val = i_bitspersample;
1378                                     if( ! val )
1379                                     {
1380                                         if( VLC_FOURCC('f', 'l', '3', '2') == i_current_fourcc )
1381                                             val = 32;
1382                                         else
1383                                             val = 16;
1384                                     }
1385
1386                                     if( val % pASCC->BitsPerSampleGranularity
1387                                      || (unsigned int)val < pASCC->MinimumBitsPerSample
1388                                      || (unsigned int)val > pASCC->MaximumBitsPerSample )
1389                                     {
1390                                         // required sample size not available, try next media type
1391                                         FreeMediaType( *p_mt );
1392                                         CoTaskMemFree( (PVOID)p_mt );
1393                                         continue;
1394                                     }
1395
1396                                     pWfx->wBitsPerSample = val;
1397                                     pWfx->nBlockAlign = (pWfx->wBitsPerSample * pWfx->nChannels)/8;
1398                                     pWfx->nAvgBytesPerSec = pWfx->nSamplesPerSec * pWfx->nBlockAlign;
1399
1400                                     // select this format as default
1401                                     if( SUCCEEDED( pSC->SetFormat(p_mt) ) )
1402                                     {
1403                                         i_priority = i_current_priority;
1404                                     }
1405                                 }
1406                             }
1407                             FreeMediaType( *p_mt );
1408                             CoTaskMemFree( (PVOID)p_mt );
1409                         }
1410                     }
1411                     CoTaskMemFree( (LPVOID)pSCC );
1412                     if( i_priority >= 0 )
1413                         msg_Dbg( p_this, "EnumDeviceCaps: input pin default format configured");
1414                 }
1415             }
1416             pSC->Release();
1417         }
1418
1419         /*
1420         ** Probe pin for available medias (may be a previously configured one)
1421         */
1422
1423         if( FAILED( p_output_pin->EnumMediaTypes( &p_enummt ) ) )
1424         {
1425             p_output_pin->Release();
1426             continue;
1427         }
1428
1429         while( p_enummt->Next( 1, &p_mt, NULL ) == S_OK )
1430         {
1431             int i_current_fourcc = GetFourCCFromMediaType( *p_mt );
1432             if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Video
1433                 && p_mt->formattype == FORMAT_VideoInfo )
1434             {
1435                 int i_current_width = ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biWidth;
1436                 int i_current_height = ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biHeight;
1437                 LONGLONG i_current_atpf = ((VIDEOINFOHEADER *)p_mt->pbFormat)->AvgTimePerFrame;
1438
1439                 if( i_current_height < 0 )
1440                     i_current_height = -i_current_height;
1441
1442                 msg_Dbg( p_this, "EnumDeviceCaps: input pin "
1443                          "accepts chroma: %4.4s, width:%i, height:%i, fps:%f",
1444                          (char *)&i_current_fourcc, i_current_width,
1445                          i_current_height, (10000000.0f/((float)i_current_atpf)) );
1446
1447                 if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
1448                     ( !i_width || i_width == i_current_width ) &&
1449                     ( !i_height || i_height == i_current_height ) &&
1450                     ( !i_AvgTimePerFrame || i_AvgTimePerFrame == i_current_atpf ) &&
1451                     mt_count < mt_max )
1452                 {
1453                     /* Pick match */
1454                     mt[mt_count++] = *p_mt;
1455                 }
1456                 else FreeMediaType( *p_mt );
1457             }
1458             else if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Audio
1459                     && p_mt->formattype == FORMAT_WaveFormatEx)
1460             {
1461                 int i_current_channels =
1462                     ((WAVEFORMATEX *)p_mt->pbFormat)->nChannels;
1463                 int i_current_samplespersec =
1464                     ((WAVEFORMATEX *)p_mt->pbFormat)->nSamplesPerSec;
1465                 int i_current_bitspersample =
1466                     ((WAVEFORMATEX *)p_mt->pbFormat)->wBitsPerSample;
1467
1468                 msg_Dbg( p_this, "EnumDeviceCaps: input pin "
1469                          "accepts format: %4.4s, channels:%i, "
1470                          "samples/sec:%i bits/sample:%i",
1471                          (char *)&i_current_fourcc, i_current_channels,
1472                          i_current_samplespersec, i_current_bitspersample);
1473
1474                 if( (!i_channels || i_channels == i_current_channels) &&
1475                     (!i_samplespersec ||
1476                      i_samplespersec == i_current_samplespersec) &&
1477                     (!i_bitspersample ||
1478                      i_bitspersample == i_current_bitspersample) &&
1479                     mt_count < mt_max )
1480                 {
1481                     /* Pick  match */
1482                     mt[mt_count++] = *p_mt;
1483
1484                     /* Setup a few properties like the audio latency */
1485                     IAMBufferNegotiation *p_ambuf;
1486                     if( SUCCEEDED( p_output_pin->QueryInterface(
1487                           IID_IAMBufferNegotiation, (void **)&p_ambuf ) ) )
1488                     {
1489                         ALLOCATOR_PROPERTIES AllocProp;
1490                         AllocProp.cbAlign = -1;
1491
1492                         /* 100 ms of latency */
1493                         AllocProp.cbBuffer = i_current_channels *
1494                           i_current_samplespersec *
1495                           i_current_bitspersample / 8 / 10;
1496
1497                         AllocProp.cbPrefix = -1;
1498                         AllocProp.cBuffers = -1;
1499                         p_ambuf->SuggestAllocatorProperties( &AllocProp );
1500                         p_ambuf->Release();
1501                     }
1502                 }
1503                 else FreeMediaType( *p_mt );
1504             }
1505             else if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Stream )
1506             {
1507                 msg_Dbg( p_this, "EnumDeviceCaps: input pin "
1508                          "accepts stream format: %4.4s",
1509                          (char *)&i_current_fourcc );
1510
1511                 if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
1512                     mt_count < mt_max )
1513                 {
1514                     /* Pick match */
1515                     mt[mt_count++] = *p_mt;
1516                     i_fourcc = i_current_fourcc;
1517                 }
1518                 else FreeMediaType( *p_mt );
1519             }
1520             else
1521             {
1522                 char *psz_type = "unknown";
1523                 if( p_mt->majortype == MEDIATYPE_Video ) psz_type = "video";
1524                 if( p_mt->majortype == MEDIATYPE_Audio ) psz_type = "audio";
1525                 if( p_mt->majortype == MEDIATYPE_Stream ) psz_type = "stream";
1526                 msg_Dbg( p_this, "EnumDeviceCaps: input pin media: unsupported format "
1527                          "(%s %4.4s)", psz_type, (char *)&p_mt->subtype );
1528
1529                 FreeMediaType( *p_mt );
1530             }
1531             CoTaskMemFree( (PVOID)p_mt );
1532         }
1533
1534         if( !mt_count && p_enummt->Reset() == S_OK )
1535         {
1536             // VLC did not find any supported MEDIATYPE for this output pin.
1537             // However the graph builder might insert converter filters in
1538             // the graph if we use a different codec in VLC filter input pin.
1539             // however, in order to avoid nasty surprises, make use of this
1540             // facility only for known unsupported codecs.
1541
1542             while( !mt_count && p_enummt->Next( 1, &p_mt, NULL ) == S_OK )
1543             {
1544                 // the first four bytes of subtype GUID contains the codec FOURCC
1545                 const char *pfcc = (char *)&p_mt->subtype;
1546                 int i_current_fourcc = VLC_FOURCC(pfcc[0], pfcc[1], pfcc[2], pfcc[3]);
1547                 if( VLC_FOURCC('H','C','W','2') == i_current_fourcc
1548                  && p_mt->majortype == MEDIATYPE_Video )
1549                 {
1550                     // output format for 'Hauppauge WinTV PVR PCI II Capture'
1551                     // try I420 as an input format
1552                     i_current_fourcc = VLC_FOURCC('I','4','2','0');
1553                     if( !i_fourcc || i_fourcc == i_current_fourcc )
1554                     {
1555                         // return alternative media type
1556                         AM_MEDIA_TYPE mtr;
1557                         VIDEOINFOHEADER vh;
1558
1559                         mtr.majortype            = MEDIATYPE_Video;
1560                         mtr.subtype              = MEDIASUBTYPE_I420;
1561                         mtr.bFixedSizeSamples    = TRUE;
1562                         mtr.bTemporalCompression = FALSE;
1563                         mtr.pUnk                 = NULL;
1564                         mtr.formattype           = FORMAT_VideoInfo;
1565                         mtr.cbFormat             = sizeof(vh);
1566                         mtr.pbFormat             = (BYTE *)&vh;
1567
1568                         memset(&vh, 0, sizeof(vh));
1569
1570                         vh.bmiHeader.biSize   = sizeof(vh.bmiHeader);
1571                         vh.bmiHeader.biWidth  = i_width > 0 ? i_width :
1572                             ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biWidth;
1573                         vh.bmiHeader.biHeight = i_height > 0 ? i_height :
1574                             ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biHeight;
1575                         vh.bmiHeader.biPlanes      = 3;
1576                         vh.bmiHeader.biBitCount    = 12;
1577                         vh.bmiHeader.biCompression = VLC_FOURCC('I','4','2','0');
1578                         vh.bmiHeader.biSizeImage   = vh.bmiHeader.biWidth * 12 *
1579                             vh.bmiHeader.biHeight / 8;
1580                         mtr.lSampleSize            = vh.bmiHeader.biSizeImage;
1581
1582                         msg_Dbg( p_this, "EnumDeviceCaps: input pin media: using 'I420' in place of unsupported format 'HCW2'");
1583
1584                         if( SUCCEEDED(CopyMediaType(mt+mt_count, &mtr)) )
1585                             ++mt_count;
1586                     }
1587                 }
1588                 FreeMediaType( *p_mt );
1589             }
1590         }
1591
1592         p_enummt->Release();
1593         p_output_pin->Release();
1594     }
1595
1596     p_enumpins->Release();
1597     return mt_count;
1598 }
1599
1600 /*****************************************************************************
1601  * ReadCompressed: reads compressed (MPEG/DV) data from the device.
1602  *****************************************************************************
1603  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
1604  * bytes.
1605  *****************************************************************************/
1606 static block_t *ReadCompressed( access_t *p_access )
1607 {
1608     access_sys_t   *p_sys = p_access->p_sys;
1609     dshow_stream_t *p_stream = NULL;
1610     VLCMediaSample sample;
1611
1612     /* Read 1 DV/MPEG frame (they contain the video and audio data) */
1613
1614     /* There must be only 1 elementary stream to produce a valid stream
1615      * of MPEG or DV data */
1616     p_stream = p_sys->pp_streams[0];
1617
1618     while( 1 )
1619     {
1620         if( p_access->b_die || p_access->b_error ) return 0;
1621
1622         /* Get new sample/frame from the elementary stream (blocking). */
1623         vlc_mutex_lock( &p_sys->lock );
1624
1625         if( p_stream->p_capture_filter->CustomGetPin()
1626               ->CustomGetSample( &sample ) != S_OK )
1627         {
1628             /* No data available. Wait until some data has arrived */
1629             vlc_cond_wait( &p_sys->wait, &p_sys->lock );
1630             vlc_mutex_unlock( &p_sys->lock );
1631             continue;
1632         }
1633
1634         vlc_mutex_unlock( &p_sys->lock );
1635
1636         /*
1637          * We got our sample
1638          */
1639         block_t *p_block;
1640         uint8_t *p_data;
1641         int i_data_size = sample.p_sample->GetActualDataLength();
1642
1643         if( !i_data_size || !(p_block = block_New( p_access, i_data_size )) )
1644         {
1645             sample.p_sample->Release();
1646             continue;
1647         }
1648
1649         sample.p_sample->GetPointer( &p_data );
1650         vlc_memcpy( p_block->p_buffer, p_data, i_data_size );
1651         sample.p_sample->Release();
1652
1653         /* The caller got what he wanted */
1654         return p_block;
1655     }
1656
1657     return 0; /* never reached */
1658 }
1659
1660 /****************************************************************************
1661  * Demux:
1662  ****************************************************************************/
1663 static int Demux( demux_t *p_demux )
1664 {
1665     access_sys_t *p_sys = (access_sys_t *)p_demux->p_sys;
1666     dshow_stream_t *p_stream = NULL;
1667     VLCMediaSample sample;
1668     int i_data_size, i_stream;
1669     uint8_t *p_data;
1670     block_t *p_block;
1671
1672     vlc_mutex_lock( &p_sys->lock );
1673
1674     /* Try to grab an audio sample (audio has a higher priority) */
1675     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
1676     {
1677         p_stream = p_sys->pp_streams[i_stream];
1678         if( p_stream->mt.majortype == MEDIATYPE_Audio &&
1679             p_stream->p_capture_filter &&
1680             p_stream->p_capture_filter->CustomGetPin()
1681               ->CustomGetSample( &sample ) == S_OK )
1682         {
1683             break;
1684         }
1685     }
1686     /* Try to grab a video sample */
1687     if( i_stream == p_sys->i_streams )
1688     {
1689         for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
1690         {
1691             p_stream = p_sys->pp_streams[i_stream];
1692             if( p_stream->p_capture_filter &&
1693                 p_stream->p_capture_filter->CustomGetPin()
1694                     ->CustomGetSample( &sample ) == S_OK )
1695             {
1696                 break;
1697             }
1698         }
1699     }
1700
1701     vlc_mutex_unlock( &p_sys->lock );
1702
1703     if( i_stream == p_sys->i_streams )
1704     {
1705         /* Sleep so we do not consume all the cpu, 10ms seems
1706          * like a good value (100fps) */
1707         msleep( 10000 );
1708         return 1;
1709     }
1710
1711     /*
1712      * We got our sample
1713      */
1714     i_data_size = sample.p_sample->GetActualDataLength();
1715     sample.p_sample->GetPointer( &p_data );
1716
1717     REFERENCE_TIME i_pts, i_end_date;
1718     HRESULT hr = sample.p_sample->GetTime( &i_pts, &i_end_date );
1719     if( hr != VFW_S_NO_STOP_TIME && hr != S_OK ) i_pts = 0;
1720
1721     if( !i_pts )
1722     {
1723         if( p_stream->mt.majortype == MEDIATYPE_Video || !p_stream->b_pts )
1724         {
1725             /* Use our data timestamp */
1726             i_pts = sample.i_timestamp;
1727             p_stream->b_pts = true;
1728         }
1729     }
1730
1731     i_pts /= 10; /* Dshow works with 100 nano-seconds resolution */
1732
1733 #if 0
1734     msg_Dbg( p_demux, "Read() stream: %i, size: %i, PTS: %"PRId64,
1735              i_stream, i_data_size, i_pts );
1736 #endif
1737
1738     p_block = block_New( p_demux, i_data_size );
1739     vlc_memcpy( p_block->p_buffer, p_data, i_data_size );
1740     p_block->i_pts = p_block->i_dts = i_pts;
1741     sample.p_sample->Release();
1742
1743     es_out_Control( p_demux->out, ES_OUT_SET_PCR, i_pts > 0 ? i_pts : 0 );
1744     es_out_Send( p_demux->out, p_stream->p_es, p_block );
1745
1746     return 1;
1747 }
1748
1749 /*****************************************************************************
1750  * AccessControl:
1751  *****************************************************************************/
1752 static int AccessControl( access_t *p_access, int i_query, va_list args )
1753 {
1754     bool   *pb_bool;
1755     int          *pi_int;
1756     int64_t      *pi_64;
1757
1758     switch( i_query )
1759     {
1760     /* */
1761     case ACCESS_CAN_SEEK:
1762     case ACCESS_CAN_FASTSEEK:
1763     case ACCESS_CAN_PAUSE:
1764     case ACCESS_CAN_CONTROL_PACE:
1765         pb_bool = (bool*)va_arg( args, bool* );
1766         *pb_bool = false;
1767         break;
1768
1769     /* */
1770     case ACCESS_GET_MTU:
1771         pi_int = (int*)va_arg( args, int * );
1772         *pi_int = 0;
1773         break;
1774
1775     case ACCESS_GET_PTS_DELAY:
1776         pi_64 = (int64_t*)va_arg( args, int64_t * );
1777         *pi_64 = (int64_t)var_GetInteger( p_access, "dshow-caching" ) * 1000;
1778         break;
1779
1780     /* */
1781     case ACCESS_SET_PAUSE_STATE:
1782     case ACCESS_GET_TITLE_INFO:
1783     case ACCESS_SET_TITLE:
1784     case ACCESS_SET_SEEKPOINT:
1785     case ACCESS_SET_PRIVATE_ID_STATE:
1786         return VLC_EGENERIC;
1787
1788     default:
1789         msg_Warn( p_access, "unimplemented query in control" );
1790         return VLC_EGENERIC;
1791     }
1792
1793     return VLC_SUCCESS;
1794 }
1795
1796 /****************************************************************************
1797  * DemuxControl:
1798  ****************************************************************************/
1799 static int DemuxControl( demux_t *p_demux, int i_query, va_list args )
1800 {
1801     bool *pb;
1802     int64_t    *pi64;
1803
1804     switch( i_query )
1805     {
1806     /* Special for access_demux */
1807     case DEMUX_CAN_PAUSE:
1808     case DEMUX_CAN_SEEK:
1809     case DEMUX_SET_PAUSE_STATE:
1810     case DEMUX_CAN_CONTROL_PACE:
1811         pb = (bool*)va_arg( args, bool * );
1812         *pb = false;
1813         return VLC_SUCCESS;
1814
1815     case DEMUX_GET_PTS_DELAY:
1816         pi64 = (int64_t*)va_arg( args, int64_t * );
1817         *pi64 = (int64_t)var_GetInteger( p_demux, "dshow-caching" ) * 1000;
1818         return VLC_SUCCESS;
1819
1820     case DEMUX_GET_TIME:
1821         pi64 = (int64_t*)va_arg( args, int64_t * );
1822         *pi64 = mdate();
1823         return VLC_SUCCESS;
1824
1825     /* TODO implement others */
1826     default:
1827         return VLC_EGENERIC;
1828     }
1829
1830     return VLC_EGENERIC;
1831 }
1832
1833 /*****************************************************************************
1834  * config variable callback
1835  *****************************************************************************/
1836 static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
1837                                vlc_value_t newval, vlc_value_t oldval, void * )
1838 {
1839     module_config_t *p_item;
1840     bool b_audio = false;
1841     int i;
1842
1843     p_item = config_FindConfig( p_this, psz_name );
1844     if( !p_item ) return VLC_SUCCESS;
1845
1846     if( !strcmp( psz_name, "dshow-adev" ) ) b_audio = true;
1847
1848     /* Clear-up the current list */
1849     if( p_item->i_list )
1850     {
1851         /* Keep the 2 first entries */
1852         for( i = 2; i < p_item->i_list; i++ )
1853         {
1854             free( const_cast<char *>(p_item->ppsz_list[i]) );
1855             free( const_cast<char *>(p_item->ppsz_list_text[i]) );
1856         }
1857         /* TODO: Remove when no more needed */
1858         p_item->ppsz_list[i] = NULL;
1859         p_item->ppsz_list_text[i] = NULL;
1860     }
1861     p_item->i_list = 2;
1862
1863     /* Find list of devices */
1864     list<string> list_devices;
1865
1866     /* Initialize OLE/COM */
1867     CoInitialize( 0 );
1868
1869     FindCaptureDevice( p_this, NULL, &list_devices, b_audio );
1870
1871     /* Uninitialize OLE/COM */
1872     CoUninitialize();
1873
1874     if( !list_devices.size() ) return VLC_SUCCESS;
1875
1876     p_item->ppsz_list =
1877         (char **)realloc( p_item->ppsz_list,
1878                           (list_devices.size()+3) * sizeof(char *) );
1879     p_item->ppsz_list_text =
1880         (char **)realloc( p_item->ppsz_list_text,
1881                           (list_devices.size()+3) * sizeof(char *) );
1882
1883     list<string>::iterator iter;
1884     for( iter = list_devices.begin(), i = 2; iter != list_devices.end();
1885          iter++, i++ )
1886     {
1887         p_item->ppsz_list[i] = strdup( iter->c_str() );
1888         p_item->ppsz_list_text[i] = NULL;
1889         p_item->i_list++;
1890     }
1891     p_item->ppsz_list[i] = NULL;
1892     p_item->ppsz_list_text[i] = NULL;
1893
1894     /* Signal change to the interface */
1895     p_item->b_dirty = true;
1896
1897     return VLC_SUCCESS;
1898 }
1899
1900 static int ConfigDevicesCallback( vlc_object_t *p_this, char const *psz_name,
1901                                vlc_value_t newval, vlc_value_t oldval, void * )
1902 {
1903     module_config_t *p_item;
1904     bool b_audio = false;
1905
1906     /* Initialize OLE/COM */
1907     CoInitialize( 0 );
1908
1909     p_item = config_FindConfig( p_this, psz_name );
1910     if( !p_item ) return VLC_SUCCESS;
1911
1912     if( !strcmp( psz_name, "dshow-adev" ) ) b_audio = true;
1913
1914     string devicename;
1915
1916     if( newval.psz_string && *newval.psz_string )
1917     {
1918         devicename = newval.psz_string;
1919     }
1920     else
1921     {
1922         /* If no device name was specified, pick the 1st one */
1923         list<string> list_devices;
1924
1925         /* Enumerate devices */
1926         FindCaptureDevice( p_this, NULL, &list_devices, b_audio );
1927         if( !list_devices.size() ) return VLC_EGENERIC;
1928         devicename = *list_devices.begin();
1929     }
1930
1931     IBaseFilter *p_device_filter =
1932         FindCaptureDevice( p_this, &devicename, NULL, b_audio );
1933     if( p_device_filter )
1934     {
1935         ShowPropertyPage( p_device_filter );
1936         p_device_filter->Release();
1937     }
1938     else
1939     {
1940         /* Uninitialize OLE/COM */
1941         CoUninitialize();
1942
1943         msg_Err( p_this, "didn't find device: %s", devicename.c_str() );
1944         return VLC_EGENERIC;
1945     }
1946
1947     /* Uninitialize OLE/COM */
1948     CoUninitialize();
1949
1950     return VLC_SUCCESS;
1951 }
1952
1953 /*****************************************************************************
1954  * Properties
1955  *****************************************************************************/
1956 static void ShowPropertyPage( IUnknown *obj )
1957 {
1958     ISpecifyPropertyPages *p_spec;
1959     CAUUID cauuid;
1960
1961     HRESULT hr = obj->QueryInterface( IID_ISpecifyPropertyPages,
1962                                       (void **)&p_spec );
1963     if( FAILED(hr) ) return;
1964
1965     if( SUCCEEDED(p_spec->GetPages( &cauuid )) )
1966     {
1967         if( cauuid.cElems > 0 )
1968         {
1969             HWND hwnd_desktop = ::GetDesktopWindow();
1970
1971             OleCreatePropertyFrame( hwnd_desktop, 30, 30, NULL, 1, &obj,
1972                                     cauuid.cElems, cauuid.pElems, 0, 0, NULL );
1973
1974             CoTaskMemFree( cauuid.pElems );
1975         }
1976         p_spec->Release();
1977     }
1978 }
1979
1980 static void ShowDeviceProperties( vlc_object_t *p_this,
1981                                   ICaptureGraphBuilder2 *p_graph,
1982                                   IBaseFilter *p_device_filter,
1983                                   bool b_audio )
1984 {
1985     HRESULT hr;
1986     msg_Dbg( p_this, "configuring Device Properties" );
1987
1988     /*
1989      * Video or audio capture filter page
1990      */
1991     ShowPropertyPage( p_device_filter );
1992
1993     /*
1994      * Audio capture pin
1995      */
1996     if( p_graph && b_audio )
1997     {
1998         IAMStreamConfig *p_SC;
1999
2000         msg_Dbg( p_this, "showing WDM Audio Configuration Pages" );
2001
2002         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2003                                      &MEDIATYPE_Audio, p_device_filter,
2004                                      IID_IAMStreamConfig, (void **)&p_SC );
2005         if( SUCCEEDED(hr) )
2006         {
2007             ShowPropertyPage(p_SC);
2008             p_SC->Release();
2009         }
2010
2011         /*
2012          * TV Audio filter
2013          */
2014         IAMTVAudio *p_TVA;
2015         HRESULT hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2016                                              &MEDIATYPE_Audio, p_device_filter,
2017                                              IID_IAMTVAudio, (void **)&p_TVA );
2018         if( SUCCEEDED(hr) )
2019         {
2020             ShowPropertyPage(p_TVA);
2021             p_TVA->Release();
2022         }
2023     }
2024
2025     /*
2026      * Video capture pin
2027      */
2028     if( p_graph && !b_audio )
2029     {
2030         IAMStreamConfig *p_SC;
2031
2032         msg_Dbg( p_this, "showing WDM Video Configuration Pages" );
2033
2034         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2035                                      &MEDIATYPE_Interleaved, p_device_filter,
2036                                      IID_IAMStreamConfig, (void **)&p_SC );
2037         if( FAILED(hr) )
2038         {
2039             hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2040                                          &MEDIATYPE_Video, p_device_filter,
2041                                          IID_IAMStreamConfig, (void **)&p_SC );
2042         }
2043
2044         if( FAILED(hr) )
2045         {
2046             hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2047                                          &MEDIATYPE_Stream, p_device_filter,
2048                                          IID_IAMStreamConfig, (void **)&p_SC );
2049         }
2050
2051         if( SUCCEEDED(hr) )
2052         {
2053             ShowPropertyPage(p_SC);
2054             p_SC->Release();
2055         }
2056     }
2057 }
2058
2059 static void ShowTunerProperties( vlc_object_t *p_this,
2060                                  ICaptureGraphBuilder2 *p_graph,
2061                                  IBaseFilter *p_device_filter,
2062                                  bool b_audio )
2063 {
2064     HRESULT hr;
2065     msg_Dbg( p_this, "configuring Tuner Properties" );
2066
2067     if( !p_graph || b_audio ) return;
2068
2069     IAMTVTuner *p_TV;
2070     hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2071                                  &MEDIATYPE_Interleaved, p_device_filter,
2072                                  IID_IAMTVTuner, (void **)&p_TV );
2073     if( FAILED(hr) )
2074     {
2075         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2076                                      &MEDIATYPE_Video, p_device_filter,
2077                                      IID_IAMTVTuner, (void **)&p_TV );
2078     }
2079
2080     if( FAILED(hr) )
2081     {
2082         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
2083                                      &MEDIATYPE_Stream, p_device_filter,
2084                                      IID_IAMTVTuner, (void **)&p_TV );
2085     }
2086
2087     if( SUCCEEDED(hr) )
2088     {
2089         ShowPropertyPage(p_TV);
2090         p_TV->Release();
2091     }
2092 }
2093
2094 static void ConfigTuner( vlc_object_t *p_this, ICaptureGraphBuilder2 *p_graph,
2095                          IBaseFilter *p_device_filter )
2096 {
2097     int i_channel, i_country, i_input, i_amtuner_mode;
2098     long l_modes = 0;
2099     IAMTVTuner *p_TV;
2100     HRESULT hr;
2101
2102     if( !p_graph ) return;
2103
2104     i_channel = var_GetInteger( p_this, "dshow-tuner-channel" );
2105     i_country = var_GetInteger( p_this, "dshow-tuner-country" );
2106     i_input = var_GetInteger( p_this, "dshow-tuner-input" );
2107     i_amtuner_mode = var_GetInteger( p_this, "dshow-amtuner-mode" );
2108
2109     if( !i_channel && !i_country && !i_input ) return; /* Nothing to do */
2110
2111     msg_Dbg( p_this, "tuner config: channel %i, country %i, input type %i",
2112              i_channel, i_country, i_input );
2113
2114     hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved,
2115                                  p_device_filter, IID_IAMTVTuner,
2116                                  (void **)&p_TV );
2117     if( FAILED(hr) )
2118     {
2119         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video,
2120                                      p_device_filter, IID_IAMTVTuner,
2121                                      (void **)&p_TV );
2122     }
2123
2124     if( FAILED(hr) )
2125     {
2126         hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Stream,
2127                                      p_device_filter, IID_IAMTVTuner,
2128                                      (void **)&p_TV );
2129     }
2130
2131     if( FAILED(hr) )
2132     {
2133         msg_Dbg( p_this, "couldn't find tuner interface" );
2134         return;
2135     }
2136
2137     hr = p_TV->GetAvailableModes( &l_modes );
2138     if( SUCCEEDED(hr) && (l_modes & i_amtuner_mode) )
2139     {
2140         hr = p_TV->put_Mode( (AMTunerModeType)i_amtuner_mode );
2141     }
2142
2143     if( i_input == 1 ) p_TV->put_InputType( 0, TunerInputCable );
2144     else if( i_input == 2 ) p_TV->put_InputType( 0, TunerInputAntenna );
2145
2146     p_TV->put_CountryCode( i_country );
2147     p_TV->put_Channel( i_channel, AMTUNER_SUBCHAN_NO_TUNE,
2148                        AMTUNER_SUBCHAN_NO_TUNE );
2149     p_TV->Release();
2150 }