* modules/access/dshow: converted to access2/demux2. Let's hope I didn't break anything ;)

modules/access/access2.c

@@ -69,6 +69,7 @@ vlc_module_begin();
     add_shortcut( "svcd" );
 
     add_shortcut( "v4l" );
+    add_shortcut( "dshow" );
 vlc_module_end();
 
 /*****************************************************************************

modules/access/dshow/dshow.cpp

@@ -37,15 +37,16 @@
 /*****************************************************************************
  * Access: local prototypes
  *****************************************************************************/
-static ssize_t Read          ( input_thread_t *, byte_t *, size_t );
-static ssize_t ReadCompressed( input_thread_t *, byte_t *, size_t );
+static int AccessRead    ( access_t *, byte_t *, int );
+static int ReadCompressed( access_t *, byte_t *, int );
+static int AccessControl ( access_t *, int, va_list );
 
-static int OpenDevice( input_thread_t *, string, vlc_bool_t );
+static int OpenDevice( access_t *, string, vlc_bool_t );
 static IBaseFilter *FindCaptureDevice( vlc_object_t *, string *,
                                        list<string> *, vlc_bool_t );
 static size_t EnumDeviceCaps( vlc_object_t *, IBaseFilter *,
                                      int, int, int, int, int, int, AM_MEDIA_TYPE *mt, size_t mt_max);
-static bool ConnectFilters( vlc_object_t *, IBaseFilter *, CaptureFilter * );
+static bool ConnectFilters( access_t *, IBaseFilter *, CaptureFilter * );
 
 static int FindDevicesCallback( vlc_object_t *, char const *,
                                 vlc_value_t, vlc_value_t, void * );
@@ -59,7 +60,7 @@ static void PropertiesPage( vlc_object_t *, IBaseFilter *,
     /* Debug only, use this to find out GUIDs */
     unsigned char p_st[];
     UuidToString( (IID *)&IID_IAMBufferNegotiation, &p_st );
-    msg_Err( p_input, "BufferNegotiation: %s" , p_st );
+    msg_Err( p_access, "BufferNegotiation: %s" , p_st );
 #endif
 
 /*
@@ -164,13 +165,13 @@ vlc_module_begin();
               VLC_FALSE );
 
     add_shortcut( "dshow" );
-    set_capability( "access", 0 );
+    set_capability( "access2", 0 );
     set_callbacks( AccessOpen, AccessClose );
 
     add_submodule();
     set_description( _("DirectShow demuxer") );
     add_shortcut( "dshow" );
-    set_capability( "demux", 200 );
+    set_capability( "demux2", 200 );
     set_callbacks( DemuxOpen, DemuxClose );
 
 vlc_module_end();
@@ -213,6 +214,7 @@ typedef struct CrossbarRouteRec {
 
 struct access_sys_t
 {
+    /* These 2 must be left at the beginning */
     vlc_mutex_t lock;
     vlc_cond_t  wait;
 
@@ -234,6 +236,7 @@ struct access_sys_t
     int            i_current_stream;
 
     /* misc properties */
+    int            i_mtu;
     int            i_width;
     int            i_height;
     int            i_chroma;
@@ -307,11 +310,11 @@ static void DeleteDirectShowGraph( access_sys_t *p_sys )
     }
 }
 
-static void ReleaseDirectShow( input_thread_t *p_input )
+static void ReleaseDirectShow( access_t *p_access )
 {
-    msg_Dbg( p_input, "Releasing DirectShow");
+    access_sys_t *p_sys = p_access->p_sys;
 
-    access_sys_t *p_sys = p_input->p_access_data;
+    msg_Dbg( p_access, "Releasing DirectShow");
 
     DeleteDirectShowGraph( p_sys );
 
@@ -326,8 +329,6 @@ static void ReleaseDirectShow( input_thread_t *p_input )
     }
     free( p_sys->pp_streams );
     free( p_sys );
-
-    p_input->p_access_data = NULL;
 }
 
 /*****************************************************************************
@@ -335,7 +336,7 @@ static void ReleaseDirectShow( input_thread_t *p_input )
  *****************************************************************************/
 static int AccessOpen( vlc_object_t *p_this )
 {
-    input_thread_t *p_input = (input_thread_t *)p_this;
+    access_t     *p_access = (access_t*)p_this;
     access_sys_t *p_sys;
     vlc_value_t  val;
 
@@ -343,20 +344,20 @@ static int AccessOpen( vlc_object_t *p_this )
     string vdevname, adevname;
     int i_width = 0, i_height = 0, i_chroma = 0;
 
-    var_Create( p_input, "dshow-config", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Create( p_access, "dshow-config", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 
-    var_Create( p_input, "dshow-vdev", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
-    var_Get( p_input, "dshow-vdev", &val );
+    var_Create( p_access, "dshow-vdev", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
+    var_Get( p_access, "dshow-vdev", &val );
     if( val.psz_string ) vdevname = string( val.psz_string );
     if( val.psz_string ) free( val.psz_string );
 
-    var_Create( p_input, "dshow-adev", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
-    var_Get( p_input, "dshow-adev", &val );
+    var_Create( p_access, "dshow-adev", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
+    var_Get( p_access, "dshow-adev", &val );
     if( val.psz_string ) adevname = string( val.psz_string );
     if( val.psz_string ) free( val.psz_string );
 
-    var_Create( p_input, "dshow-size", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
-    var_Get( p_input, "dshow-size", &val );
+    var_Create( p_access, "dshow-size", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
+    var_Get( p_access, "dshow-size", &val );
     if( val.psz_string && *val.psz_string )
     {
         if( !strcmp( val.psz_string, "subqcif" ) )
@@ -392,13 +393,13 @@ static int AccessOpen( vlc_object_t *p_this )
             {
                 i_height = strtol( psz_parser + 1, &psz_parser, 0 );
             }
-            msg_Dbg( p_input, "Width x Height %dx%d", i_width, i_height );
+            msg_Dbg( p_access, "Width x Height %dx%d", i_width, i_height );
         }
     }
     if( val.psz_string ) free( val.psz_string );
 
-    var_Create( p_input, "dshow-chroma", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
-    var_Get( p_input, "dshow-chroma", &val );
+    var_Create( p_access, "dshow-chroma", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
+    var_Get( p_access, "dshow-chroma", &val );
     if( val.psz_string && strlen( val.psz_string ) >= 4 )
     {
         i_chroma = VLC_FOURCC( val.psz_string[0], val.psz_string[1],
@@ -406,30 +407,26 @@ static int AccessOpen( vlc_object_t *p_this )
     }
     if( val.psz_string ) free( val.psz_string );
 
-    p_input->pf_read        = Read;
-    p_input->pf_seek        = NULL;
-    p_input->pf_set_area    = NULL;
-    p_input->pf_set_program = NULL;
-
-    vlc_mutex_lock( &p_input->stream.stream_lock );
-    p_input->stream.b_pace_control = 0;
-    p_input->stream.b_seekable = 0;
-    p_input->stream.p_selected_area->i_size = 0;
-    p_input->stream.p_selected_area->i_tell = 0;
-    p_input->stream.i_method = INPUT_METHOD_FILE;
-    vlc_mutex_unlock( &p_input->stream.stream_lock );
-
-    var_Create( p_input, "dshow-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
-    var_Get( p_input, "dshow-caching", &val );
-    p_input->i_pts_delay = val.i_int * 1000;
+    /* Setup Access */
+    p_access->pf_read = AccessRead;
+    p_access->pf_block = NULL;
+    p_access->pf_control = AccessControl;
+    p_access->pf_seek = NULL;
+    p_access->info.i_update = 0;
+    p_access->info.i_size = 0;
+    p_access->info.i_pos = 0;
+    p_access->info.b_eof = VLC_FALSE;
+    p_access->info.i_title = 0;
+    p_access->info.i_seekpoint = 0;
+    p_access->p_sys = p_sys = (access_sys_t *)malloc( sizeof( access_sys_t ) );
+    memset( p_sys, 0, sizeof( access_sys_t ) );
+
+    var_Create( p_access, "dshow-caching",
+                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 
     /* Initialize OLE/COM */
     CoInitialize( 0 );
 
-    /* create access private data */
-    p_input->p_access_data = p_sys =
-        (access_sys_t *)malloc( sizeof( access_sys_t ) );
-
     /* Initialize some data */
     p_sys->i_streams = 0;
     p_sys->pp_streams = (dshow_stream_t **)malloc( 1 );
@@ -437,6 +434,7 @@ static int AccessOpen( vlc_object_t *p_this )
     p_sys->i_height = i_height;
     p_sys->i_chroma = i_chroma;
     p_sys->b_audio = VLC_TRUE;
+    p_sys->i_mtu = 0;
 
     /* Create header */
     p_sys->i_header_size = 8;
@@ -452,14 +450,14 @@ static int AccessOpen( vlc_object_t *p_this )
     /* Build directshow graph */
     CreateDirectShowGraph( p_sys );
 
-    if( OpenDevice( p_input, vdevname, 0 ) != VLC_SUCCESS )
+    if( OpenDevice( p_access, vdevname, 0 ) != VLC_SUCCESS )
     {
-        msg_Err( p_input, "can't open video");
+        msg_Err( p_access, "can't open video");
     }
 
-    if( p_sys->b_audio && OpenDevice( p_input, adevname, 1 ) != VLC_SUCCESS )
+    if( p_sys->b_audio && OpenDevice( p_access, adevname, 1 ) != VLC_SUCCESS )
     {
-        msg_Err( p_input, "can't open audio");
+        msg_Err( p_access, "can't open audio");
     }
     
     for( int i = 0; i < p_sys->i_crossbar_route_depth; i++ )
@@ -472,15 +470,16 @@ static int AccessOpen( vlc_object_t *p_this )
 
         if( SUCCEEDED(pXbar->Route(VideoOutputIndex, VideoInputIndex)) )
         {
-            msg_Dbg( p_input, "Crossbar at depth %d, Routed video ouput %d to "
-                     "video input %d", i, VideoOutputIndex, VideoInputIndex );
+            msg_Dbg( p_access, "Crossbar at depth %d, Routed video "
+                     "ouput %d to video input %d", i, VideoOutputIndex,
+                     VideoInputIndex );
 
             if( AudioOutputIndex != -1 && AudioInputIndex != -1 )
             {
                 if( SUCCEEDED( pXbar->Route(AudioOutputIndex,
                                             AudioInputIndex)) )
                 {
-                    msg_Dbg(p_input, "Crossbar at depth %d, Routed audio "
+                    msg_Dbg(p_access, "Crossbar at depth %d, Routed audio "
                             "ouput %d to audio input %d", i,
                             AudioOutputIndex, AudioInputIndex );
                 }
@@ -490,18 +489,17 @@ static int AccessOpen( vlc_object_t *p_this )
 
     if( !p_sys->i_streams )
     {
-        ReleaseDirectShow( p_input );
+        ReleaseDirectShow( p_access );
         return VLC_EGENERIC;
     }
 
     /* Initialize some data */
     p_sys->i_current_stream = 0;
-    p_input->i_mtu += p_sys->i_header_size + 16 /* data header size */;
-
-    vlc_mutex_init( p_input, &p_sys->lock );
-    vlc_cond_init( p_input, &p_sys->wait );
+    p_sys->i_mtu += p_sys->i_header_size + 16 /* data header size */;
+    vlc_mutex_init( p_access, &p_sys->lock );
+    vlc_cond_init( p_access, &p_sys->wait );
 
-    msg_Dbg( p_input, "Playing...");
+    msg_Dbg( p_access, "Playing...");
 
     /* Everything is ready. Let's rock baby */
     p_sys->p_control->Run();
@@ -514,13 +512,61 @@ static int AccessOpen( vlc_object_t *p_this )
  *****************************************************************************/
 static void AccessClose( vlc_object_t *p_this )
 {
-    input_thread_t *p_input = (input_thread_t *)p_this;
-    access_sys_t   *p_sys   = p_input->p_access_data;
+    access_t     *p_access = (access_t *)p_this;
+    access_sys_t *p_sys    = p_access->p_sys;
 
     /* Stop capturing stuff */
     p_sys->p_control->Stop();
 
-    ReleaseDirectShow(p_input);
+    ReleaseDirectShow( p_access );
+}
+
+/*****************************************************************************
+ * AccessControl:
+ *****************************************************************************/
+static int AccessControl( access_t *p_access, int i_query, va_list args )
+{
+    access_sys_t *p_sys = p_access->p_sys;
+    vlc_bool_t   *pb_bool;
+    int          *pi_int;
+    int64_t      *pi_64;
+
+    switch( i_query )
+    {
+        /* */
+        case ACCESS_CAN_SEEK:
+        case ACCESS_CAN_FASTSEEK:
+        case ACCESS_CAN_PAUSE:
+        case ACCESS_CAN_CONTROL_PACE:
+            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
+            *pb_bool = VLC_FALSE;
+            break;
+
+        /* */
+        case ACCESS_GET_MTU:
+            pi_int = (int*)va_arg( args, int * );
+            *pi_int = p_sys->i_mtu;
+            break;
+
+        case ACCESS_GET_PTS_DELAY:
+            pi_64 = (int64_t*)va_arg( args, int64_t * );
+            *pi_64 = (int64_t)var_GetInteger( p_access, "dshow-caching" ) *
+                                              I64C(1000);
+            break;
+
+        /* */
+        case ACCESS_SET_PAUSE_STATE:
+        case ACCESS_GET_TITLE_INFO:
+        case ACCESS_SET_TITLE:
+        case ACCESS_SET_SEEKPOINT:
+            return VLC_EGENERIC;
+
+        default:
+            msg_Err( p_access, "unimplemented query in control" );
+            return VLC_EGENERIC;
+
+    }
+    return VLC_SUCCESS;
 }
 
 /****************************************************************************
@@ -613,10 +659,10 @@ static HRESULT GetCrossbarIndexFromIPin( IAMCrossbar * pXbar, LONG * PinIndex,
 /****************************************************************************
  * FindCrossbarRoutes
  ****************************************************************************/
-static HRESULT FindCrossbarRoutes( vlc_object_t *p_this, IPin *p_input_pin,
+static HRESULT FindCrossbarRoutes( access_t *p_access, IPin *p_input_pin,
                                    LONG physicalType, int depth = 0 )
 {
-    access_sys_t *p_sys = ((input_thread_t *)p_this)->p_access_data;
+    access_sys_t *p_sys = p_access->p_sys;
     HRESULT result = S_FALSE;
 
     IPin *p_output_pin;
@@ -683,7 +729,7 @@ static HRESULT FindCrossbarRoutes( vlc_object_t *p_this, IPin *p_input_pin,
         if( FAILED(GetCrossbarIPinAtIndex( pXbar, inputPinIndex,
                                            TRUE, &pPin)) ) continue;
 
-        result = FindCrossbarRoutes( p_this, pPin, physicalType, depth+1 );
+        result = FindCrossbarRoutes( p_access, pPin, physicalType, depth+1 );
         if( S_OK == result || (S_FALSE == result &&
               physicalType == inputPinPhysicalType &&
               (p_sys->i_crossbar_route_depth = depth+1) < MAX_CROSSBAR_DEPTH) )
@@ -698,8 +744,8 @@ static HRESULT FindCrossbarRoutes( vlc_object_t *p_this, IPin *p_input_pin,
             p_sys->crossbar_routes[depth].AudioInputIndex = inputPinIndexRelated;
             p_sys->crossbar_routes[depth].AudioOutputIndex = outputPinIndexRelated;
 
-            msg_Dbg( p_this, "Crossbar at depth %d, Found Route For ouput %ld "
-                     "(type %ld) to input %d (type %ld)", depth,
+            msg_Dbg( p_access, "Crossbar at depth %d, Found Route For "
+                     "ouput %ld (type %ld) to input %d (type %ld)", depth,
                      outputPinIndex, outputPinPhysicalType, inputPinIndex,
                      inputPinPhysicalType );
 
@@ -717,10 +763,10 @@ static HRESULT FindCrossbarRoutes( vlc_object_t *p_this, IPin *p_input_pin,
 /****************************************************************************
  * ConnectFilters
  ****************************************************************************/
-static bool ConnectFilters( vlc_object_t *p_this, IBaseFilter *p_filter,
+static bool ConnectFilters( access_t *p_access, IBaseFilter *p_filter,
                             CaptureFilter *p_capture_filter )
 {
-    access_sys_t *p_sys = ((input_thread_t *)p_this)->p_access_data;
+    access_sys_t *p_sys = p_access->p_sys;
     CapturePin *p_input_pin = p_capture_filter->CustomGetPin();
 
     AM_MEDIA_TYPE mediaType = p_input_pin->CustomGetMediaType();
@@ -766,7 +812,7 @@ static bool ConnectFilters( vlc_object_t *p_this, IBaseFilter *p_filter,
                                 if( guid == PIN_CATEGORY_ANALOGVIDEOIN )
                                 {
                                     // recursively search crossbar routes
-                                    FindCrossbarRoutes( p_this, pP,
+                                    FindCrossbarRoutes( p_access, pP,
                                                         PhysConn_Video_Tuner );
                                     // found it
                                     Found = TRUE;
@@ -847,10 +893,10 @@ static int GetFourCCPriority(int i_fourcc)
 
 #define MAX_MEDIA_TYPES 32
 
-static int OpenDevice( input_thread_t *p_input, string devicename,
+static int OpenDevice( access_t *p_access, string devicename,
                        vlc_bool_t b_audio )
 {
-    access_sys_t *p_sys = p_input->p_access_data;
+    access_sys_t *p_sys = p_access->p_sys;
 
     /* See if device is already opened */
     for( int i = 0; i < p_sys->i_streams; i++ )
@@ -865,14 +911,14 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
     list<string> list_devices;
 
     /* Enumerate devices and display their names */
-    FindCaptureDevice( (vlc_object_t *)p_input, NULL, &list_devices, b_audio );
+    FindCaptureDevice( (vlc_object_t *)p_access, NULL, &list_devices, b_audio );
 
     if( !list_devices.size() )
         return VLC_EGENERIC;
 
     list<string>::iterator iter;
     for( iter = list_devices.begin(); iter != list_devices.end(); iter++ )
-        msg_Dbg( p_input, "found device: %s", iter->c_str() );
+        msg_Dbg( p_access, "found device: %s", iter->c_str() );
 
     /* If no device name was specified, pick the 1st one */
     if( devicename.size() == 0 )
@@ -883,38 +929,45 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
     // Use the system device enumerator and class enumerator to find
     // a capture/preview device, such as a desktop USB video camera.
     IBaseFilter *p_device_filter =
-        FindCaptureDevice( (vlc_object_t *)p_input, &devicename,
+        FindCaptureDevice( (vlc_object_t *)p_access, &devicename,
                            NULL, b_audio );
     if( p_device_filter )
-        msg_Dbg( p_input, "using device: %s", devicename.c_str() );
+        msg_Dbg( p_access, "using device: %s", devicename.c_str() );
     else
     {
-        msg_Err( p_input, "can't use device: %s, unsupported device type", devicename.c_str() );
+        msg_Err( p_access, "can't use device: %s, unsupported device type",
+                 devicename.c_str() );
         return VLC_EGENERIC;
     }
 
     AM_MEDIA_TYPE media_types[MAX_MEDIA_TYPES];
 
-    size_t mt_count = EnumDeviceCaps( (vlc_object_t *)p_input, p_device_filter,
-                                                                p_sys->i_chroma, p_sys->i_width, p_sys->i_height,
+    size_t mt_count = EnumDeviceCaps( (vlc_object_t *)p_access,
+                                      p_device_filter, p_sys->i_chroma,
+                                      p_sys->i_width, p_sys->i_height,
                                       0, 0, 0, media_types, MAX_MEDIA_TYPES );
 
     if( 0 == mt_count )
     {
-        msg_Err( p_input, "can't use device: %s, unsupported media types", devicename.c_str() );
+        msg_Err( p_access, "can't use device: %s, unsupported media types",
+                 devicename.c_str() );
         return VLC_EGENERIC;
     }
  
-    AM_MEDIA_TYPE *mt = (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
+    AM_MEDIA_TYPE *mt =
+        (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
 
-    //order and copy returned media types according to arbitrary fourcc priority
+    // Order and copy returned media types according to arbitrary
+    // fourcc priority
     for( size_t c=0; c<mt_count; c++ )
     {
-	int slot_priority = GetFourCCPriority(GetFourCCFromMediaType(media_types[c]));
+        int slot_priority =
+            GetFourCCPriority(GetFourCCFromMediaType(media_types[c]));
         int slot_copy = c;
         for( size_t d=c+1; d<mt_count; d++ )
         {
-	    int priority = GetFourCCPriority(GetFourCCFromMediaType(media_types[d]));
+            int priority =
+                GetFourCCPriority(GetFourCCFromMediaType(media_types[d]));
             if( priority > slot_priority )
             {
                 slot_priority = priority;
@@ -933,7 +986,8 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
     }
 
     /* Create and add our capture filter */
-    CaptureFilter *p_capture_filter = new CaptureFilter( p_input, mt, mt_count );
+    CaptureFilter *p_capture_filter =
+        new CaptureFilter( p_access, mt, mt_count );
     p_sys->p_graph->AddFilter( p_capture_filter, 0 );
 
     /* Add the device filter to the graph (seems necessary with VfW before
@@ -941,12 +995,11 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
     p_sys->p_graph->AddFilter( p_device_filter, 0 );
 
     /* Attempt to connect one of this device's capture output pins */
-    msg_Dbg( p_input, "connecting filters" );
-    if( ConnectFilters( VLC_OBJECT(p_input), p_device_filter,
-                        p_capture_filter ) )
+    msg_Dbg( p_access, "connecting filters" );
+    if( ConnectFilters( p_access, p_device_filter, p_capture_filter ) )
     {
         /* Success */
-        msg_Dbg( p_input, "filters connected successfully !" );
+        msg_Dbg( p_access, "filters connected successfully !" );
 
         dshow_stream_t dshow_stream;
         dshow_stream.b_invert = VLC_FALSE;
@@ -957,10 +1010,10 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
         /* Show properties. Done here so the VLC stream is setup with the
          * proper parameters. */
         vlc_value_t val;
-        var_Get( p_input, "dshow-config", &val );
+        var_Get( p_access, "dshow-config", &val );
         if( val.i_int )
         {
-            PropertiesPage( VLC_OBJECT(p_input), p_device_filter,
+            PropertiesPage( VLC_OBJECT(p_access), p_device_filter,
                             p_sys->p_capture_graph_builder2,
                             dshow_stream.mt.majortype == MEDIATYPE_Audio );
         }
@@ -973,7 +1026,7 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
         {
             if( dshow_stream.mt.majortype == MEDIATYPE_Video )
             {
-                                msg_Dbg( p_input, "MEDIATYPE_Video");
+                msg_Dbg( p_access, "MEDIATYPE_Video");
 
                 dshow_stream.header.video =
                     *(VIDEOINFOHEADER *)dshow_stream.mt.pbFormat;
@@ -981,39 +1034,39 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
                 int i_height = dshow_stream.header.video.bmiHeader.biHeight;
 
                 /* Check if the image is inverted (bottom to top) */
-                                if( dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'G', 'B', '1' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'G', 'B', '4' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'G', 'B', '8' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'V', '1', '5' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'V', '1', '6' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'V', '2', '4' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'V', '3', '2' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
+                if( dshow_stream.i_fourcc == VLC_FOURCC('R','G','B','1') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','G','B','4') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','G','B','8') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','V','1','5') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','V','1','6') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','V','2','4') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','V','3','2') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('R','G','B','A') )
                 {
                     if( i_height > 0 ) dshow_stream.b_invert = VLC_TRUE;
                     else i_height = - i_height;
                 }
 
                 /* Check if we are dealing with a DV stream */
-                                if( dshow_stream.i_fourcc == VLC_FOURCC( 'd', 'v', 's', 'l' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'd', 'v', 's', 'd' ) ||
-                                        dshow_stream.i_fourcc == VLC_FOURCC( 'd', 'v', 'h', 'd' ) )
+                if( dshow_stream.i_fourcc == VLC_FOURCC('d','v','s','l') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('d','v','s','d') ||
+                    dshow_stream.i_fourcc == VLC_FOURCC('d','v','h','d') )
                 {
-                                        p_input->pf_read = ReadCompressed;
-                                        if( !p_input->psz_demux || !*p_input->psz_demux )
+                    p_access->pf_read = ReadCompressed;
+                    if( !p_access->psz_demux || !*p_access->psz_demux )
                     {
-                                                p_input->psz_demux = "rawdv";
+                        p_access->psz_demux = strdup( "rawdv" );
                     }
                     p_sys->b_audio = VLC_FALSE;
                 }
 
                 /* Check if we are dealing with an MPEG video stream */
-                                if( dshow_stream.i_fourcc == VLC_FOURCC( 'm', 'p', '2', 'v' ) )
+                if( dshow_stream.i_fourcc == VLC_FOURCC('m','p','2','v') )
                 {
-                                        p_input->pf_read = ReadCompressed;
-                                        if( !p_input->psz_demux || !*p_input->psz_demux )
+                    p_access->pf_read = ReadCompressed;
+                    if( !p_access->psz_demux || !*p_access->psz_demux )
                     {
-                                                p_input->psz_demux = "mpgv";
+                        p_access->psz_demux = "mpgv";
                     }
                     p_sys->b_audio = VLC_FALSE;
                 }
@@ -1034,12 +1087,12 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
                 /* Greatly simplifies the reading routine */
                 int i_mtu = dshow_stream.header.video.bmiHeader.biWidth *
                     i_height * 4;
-                                p_input->i_mtu = __MAX( p_input->i_mtu, (unsigned int)i_mtu );
+                p_sys->i_mtu = __MAX( p_sys->i_mtu, (unsigned int)i_mtu );
             }
 
             else if( dshow_stream.mt.majortype == MEDIATYPE_Audio )
             {
-                                msg_Dbg( p_input, "MEDIATYPE_Audio");
+                msg_Dbg( p_access, "MEDIATYPE_Audio");
 
                 dshow_stream.header.audio =
                     *(WAVEFORMATEX *)dshow_stream.mt.pbFormat;
@@ -1082,27 +1135,26 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
                         dshow_stream.header.audio.wBitsPerSample / 8;
                 }
                 p_pin->Release();
-                                p_input->i_mtu = __MAX( p_input->i_mtu, (unsigned int)i_mtu );
+                p_sys->i_mtu = __MAX( p_sys->i_mtu, (unsigned int)i_mtu );
             }
 
             else if( dshow_stream.mt.majortype == MEDIATYPE_Stream )
             {
-                                msg_Dbg( p_input, "MEDIATYPE_Stream" );
+                msg_Dbg( p_access, "MEDIATYPE_Stream" );
 
-                                msg_Dbg( p_input, "selected stream pin accepts format: %4.4s",
+                msg_Dbg( p_access, "selected stream pin accepts format: %4.4s",
                          (char *)&dshow_stream.i_fourcc);
 
                 p_sys->b_audio = VLC_FALSE;
                 p_sys->i_header_size = 0;
                 p_sys->i_header_pos = 0;
-                                p_input->i_mtu = INPUT_DEFAULT_BUFSIZE;
+                p_sys->i_mtu = 0;
 
-                                p_input->pf_read = ReadCompressed;
-                                p_input->pf_set_program = input_SetProgram;
+                p_access->pf_read = ReadCompressed;
             }
             else
             {
-                                msg_Dbg( p_input, "unknown stream majortype" );
+                msg_Dbg( p_access, "unknown stream majortype" );
                 goto fail;
             }
 
@@ -1110,10 +1162,8 @@ static int OpenDevice( input_thread_t *p_input, string devicename,
             dshow_stream.p_device_filter = p_device_filter;
             dshow_stream.p_capture_filter = p_capture_filter;
 
-                        p_sys->pp_streams =
-                                (dshow_stream_t **)realloc( p_sys->pp_streams,
-                                                                                        sizeof(dshow_stream_t *)
-                                                                                        * (p_sys->i_streams + 1) );
+            p_sys->pp_streams = (dshow_stream_t **)realloc( p_sys->pp_streams,
+                sizeof(dshow_stream_t *) * (p_sys->i_streams + 1) );
             p_sys->pp_streams[p_sys->i_streams] = new dshow_stream_t;
             *p_sys->pp_streams[p_sys->i_streams++] = dshow_stream;
             SetDWBE( &p_sys->p_header[4], (uint32_t)p_sys->i_streams );
@@ -1232,11 +1282,11 @@ FindCaptureDevice( vlc_object_t *p_this, string *p_devicename,
     return NULL;
 }
 
-static size_t EnumDeviceCaps( vlc_object_t *p_this,
-                                     IBaseFilter *p_filter,
+static size_t EnumDeviceCaps( vlc_object_t *p_this, IBaseFilter *p_filter,
                               int i_fourcc, int i_width, int i_height,
                               int i_channels, int i_samplespersec,
-                                     int i_bitspersample, AM_MEDIA_TYPE *mt, size_t mt_max )
+                              int i_bitspersample, AM_MEDIA_TYPE *mt,
+                              size_t mt_max )
 {
     IEnumPins *p_enumpins;
     IPin *p_output_pin;
@@ -1261,7 +1311,7 @@ static size_t EnumDeviceCaps( vlc_object_t *p_this,
     }
     p_enumpins->Reset();
 
-    while( (0 == mt_count) && p_enumpins->Next( 1, &p_output_pin, NULL ) == S_OK )
+    while( !mt_count && p_enumpins->Next( 1, &p_output_pin, NULL ) == S_OK )
     {
         PIN_INFO info;
 
@@ -1404,15 +1454,14 @@ static size_t EnumDeviceCaps( vlc_object_t *p_this,
 }
 
 /*****************************************************************************
- * Read: reads from the device into PES packets.
+ * AccessRead: reads from the device.
  *****************************************************************************
  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
  * bytes.
  *****************************************************************************/
-static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer,
-                     size_t i_len )
+static int AccessRead( access_t *p_access, uint8_t *p_buffer, int i_len )
 {
-    access_sys_t   *p_sys = p_input->p_access_data;
+    access_sys_t   *p_sys = p_access->p_sys;
     dshow_stream_t *p_stream = NULL;
     byte_t         *p_buf_orig = p_buffer;
     VLCMediaSample  sample;
@@ -1489,16 +1538,16 @@ static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer,
         }
 
 #if 0
-        msg_Dbg( p_input, "Read() stream: %i PTS: "I64Fd, i_stream, i_pts );
+        msg_Dbg( p_access, "Read() stream: %i PTS: "I64Fd, i_stream, i_pts );
 #endif
 
         /* Create pseudo header */
         SetDWBE( &p_sys->p_header[0], i_stream );
         SetDWBE( &p_sys->p_header[4], i_data_size );
-        SetQWBE( &p_sys->p_header[8], i_pts  * 9 / 1000 );
+        SetQWBE( &p_sys->p_header[8], i_pts / 10 );
 
 #if 0
-        msg_Info( p_input, "access read %i data_size %i", i_len, i_data_size );
+        msg_Info( p_access, "access read %i data_size %i", i_len, i_data_size );
 #endif
 
         /* First copy header */
@@ -1508,7 +1557,7 @@ static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer,
         /* Then copy stream data if any */
         if( !p_stream->b_invert )
         {
-            p_input->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
+            p_access->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
             p_buffer += i_data_size;
         }
         else
@@ -1534,7 +1583,7 @@ static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer,
 
             for( int i = i_height - 1; i >= 0; i-- )
             {
-                p_input->p_vlc->pf_memcpy( p_buffer,
+                p_access->p_vlc->pf_memcpy( p_buffer,
                      &p_data[i * i_width], i_width );
 
                 p_buffer += i_width;
@@ -1556,10 +1605,9 @@ static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer,
  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
  * bytes.
  *****************************************************************************/
-static ssize_t ReadCompressed( input_thread_t * p_input, byte_t * p_buffer,
-                               size_t i_len )
+static int ReadCompressed( access_t *p_access, uint8_t *p_buffer, int i_len )
 {
-    access_sys_t   *p_sys = p_input->p_access_data;
+    access_sys_t   *p_sys = p_access->p_sys;
     dshow_stream_t *p_stream = NULL;
     VLCMediaSample  sample;
     int             i_data_size;
@@ -1573,7 +1621,7 @@ static ssize_t ReadCompressed( input_thread_t * p_input, byte_t * p_buffer,
 
     while( 1 )
     {
-        if( p_input->b_die || p_input->b_error ) return 0;
+        if( p_access->b_die || p_access->b_error ) return 0;
 
         /* Get new sample/frame from the elementary stream (blocking). */
         vlc_mutex_lock( &p_sys->lock );
@@ -1596,11 +1644,11 @@ static ssize_t ReadCompressed( input_thread_t * p_input, byte_t * p_buffer,
         sample.p_sample->GetPointer( &p_data );
 
 #if 0
-        msg_Info( p_input, "access read %i data_size %i", i_len, i_data_size );
+        msg_Info( p_access, "access read %i data_size %i", i_len, i_data_size );
 #endif
         i_data_size = __MIN( i_data_size, (int)i_len );
 
-        p_input->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
+        p_access->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
 
         sample.p_sample->Release();
 
@@ -1620,14 +1668,15 @@ struct demux_sys_t
     es_out_id_t **es;
 };
 
-static int  Demux      ( input_thread_t * );
+static int  Demux      ( demux_t * );
+static int DemuxControl( demux_t *, int, va_list );
 
 /****************************************************************************
  * DemuxOpen:
  ****************************************************************************/
 static int DemuxOpen( vlc_object_t *p_this )
 {
-    input_thread_t *p_input = (input_thread_t *)p_this;
+    demux_t     *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys;
 
     uint8_t     *p_peek;
@@ -1635,39 +1684,28 @@ static int DemuxOpen( vlc_object_t *p_this )
     int         i;
 
     /* a little test to see if it's a dshow stream */
-    if( stream_Peek( p_input->s, &p_peek, 8 ) < 8 )
+    if( stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
     {
-        msg_Warn( p_input, "dshow plugin discarded (cannot peek)" );
+        msg_Warn( p_demux, "dshow plugin discarded (cannot peek)" );
         return VLC_EGENERIC;
     }
 
     if( memcmp( p_peek, ".dsh", 4 ) ||
         ( i_es = GetDWBE( &p_peek[4] ) ) <= 0 )
     {
-        msg_Warn( p_input, "dshow plugin discarded (not a valid stream)" );
-        return VLC_EGENERIC;
-    }
-
-    vlc_mutex_lock( &p_input->stream.stream_lock );
-    if( input_InitStream( p_input, 0 ) == -1)
-    {
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-        msg_Err( p_input, "cannot init stream" );
+        msg_Warn( p_demux, "dshow plugin discarded (not a valid stream)" );
         return VLC_EGENERIC;
     }
-    p_input->stream.i_mux_rate =  0 / 50;
-    vlc_mutex_unlock( &p_input->stream.stream_lock );
 
-    p_input->pf_demux = Demux;
-    p_input->pf_demux_control = demux_vaControlDefault;
-    p_input->p_demux_data = p_sys =
-        (demux_sys_t *)malloc( sizeof( demux_sys_t ) );
+    p_demux->pf_demux   = Demux;
+    p_demux->pf_control = DemuxControl;
+    p_demux->p_sys = p_sys = (demux_sys_t *)malloc( sizeof( demux_sys_t ) );
     p_sys->i_es = 0;
     p_sys->es   = NULL;
 
-    if( stream_Peek( p_input->s, &p_peek, 8 + 20 * i_es ) < 8 + 20 * i_es )
+    if( stream_Peek( p_demux->s, &p_peek, 8 + 20 * i_es ) < 8 + 20 * i_es )
     {
-        msg_Err( p_input, "dshow plugin discarded (cannot peek)" );
+        msg_Err( p_demux, "dshow plugin discarded (cannot peek)" );
         return VLC_EGENERIC;
     }
     p_peek += 8;
@@ -1690,12 +1728,12 @@ static int DemuxOpen( vlc_object_t *p_this )
                             fmt.audio.i_rate *
                             fmt.audio.i_bitspersample;
 
-            msg_Dbg( p_input, "new audio es %d channels %dHz",
+            msg_Dbg( p_demux, "new audio es %d channels %dHz",
                      fmt.audio.i_channels, fmt.audio.i_rate );
 
             p_sys->es = (es_out_id_t **)realloc( p_sys->es,
                           sizeof(es_out_id_t *) * (p_sys->i_es + 1) );
-            p_sys->es[p_sys->i_es++] = es_out_Add( p_input->p_es_out, &fmt );
+            p_sys->es[p_sys->i_es++] = es_out_Add( p_demux->out, &fmt );
         }
         else if( !memcmp( p_peek, "vids", 4 ) )
         {
@@ -1704,20 +1742,20 @@ static int DemuxOpen( vlc_object_t *p_this )
             fmt.video.i_width  = GetDWBE( &p_peek[8] );
             fmt.video.i_height = GetDWBE( &p_peek[12] );
 
-            msg_Dbg( p_input, "added new video es %4.4s %dx%d",
+            msg_Dbg( p_demux, "added new video es %4.4s %dx%d",
                      (char*)&fmt.i_codec,
                      fmt.video.i_width, fmt.video.i_height );
 
             p_sys->es = (es_out_id_t **)realloc( p_sys->es,
                           sizeof(es_out_id_t *) * (p_sys->i_es + 1) );
-            p_sys->es[p_sys->i_es++] = es_out_Add( p_input->p_es_out, &fmt );
+            p_sys->es[p_sys->i_es++] = es_out_Add( p_demux->out, &fmt );
         }
 
         p_peek += 20;
     }
 
     /* Skip header */
-    stream_Read( p_input->s, NULL, 8 + 20 * i_es );
+    stream_Read( p_demux->s, NULL, 8 + 20 * i_es );
 
     return VLC_SUCCESS;
 }
@@ -1727,8 +1765,8 @@ static int DemuxOpen( vlc_object_t *p_this )
  ****************************************************************************/
 static void DemuxClose( vlc_object_t *p_this )
 {
-    input_thread_t *p_input = (input_thread_t *)p_this;
-    demux_sys_t    *p_sys = p_input->p_demux_data;
+    demux_t     *p_demux = (demux_t *)p_this;
+    demux_sys_t *p_sys = p_demux->p_sys;
 
     if( p_sys->i_es > 0 )
     {
@@ -1740,54 +1778,57 @@ static void DemuxClose( vlc_object_t *p_this )
 /****************************************************************************
  * Demux:
  ****************************************************************************/
-static int Demux( input_thread_t *p_input )
+static int Demux( demux_t *p_demux )
 {
-    demux_sys_t *p_sys = p_input->p_demux_data;
+    demux_sys_t *p_sys = p_demux->p_sys;
     block_t     *p_block;
 
     int i_es;
     int i_size;
 
     uint8_t *p_peek;
-    mtime_t i_pcr;
+    mtime_t i_pts;
 
-    if( stream_Peek( p_input->s, &p_peek, 16 ) < 16 )
+    if( stream_Peek( p_demux->s, &p_peek, 16 ) < 16 )
     {
-        msg_Warn( p_input, "cannot peek (EOF ?)" );
+        msg_Warn( p_demux, "cannot peek (EOF ?)" );
         return 0;
     }
 
     i_es = GetDWBE( &p_peek[0] );
     if( i_es < 0 || i_es >= p_sys->i_es )
     {
-        msg_Err( p_input, "cannot find ES" );
+        msg_Err( p_demux, "cannot find ES" );
         return -1;
     }
 
     i_size = GetDWBE( &p_peek[4] );
-    i_pcr  = GetQWBE( &p_peek[8] );
+    i_pts  = GetQWBE( &p_peek[8] );
 
-    if( ( p_block = stream_Block( p_input->s, 16 + i_size ) ) == NULL )
+    if( ( p_block = stream_Block( p_demux->s, 16 + i_size ) ) == NULL )
     {
-        msg_Warn( p_input, "cannot read data" );
+        msg_Warn( p_demux, "cannot read data" );
         return 0;
     }
 
     p_block->p_buffer += 16;
     p_block->i_buffer -= 16;
 
-    /* Call the pace control. */
-    input_ClockManageRef( p_input, p_input->stream.p_selected_program, i_pcr );
-
-    p_block->i_dts =
-    p_block->i_pts = i_pcr <= 0 ? 0 :
-        input_ClockGetTS( p_input, p_input->stream.p_selected_program, i_pcr );
+    p_block->i_dts = p_block->i_pts = i_pts;
 
-    es_out_Send( p_input->p_es_out, p_sys->es[i_es], p_block );
+    es_out_Control( p_demux->out, ES_OUT_SET_PCR, i_pts > 0 ? i_pts : 0 );
+    es_out_Send( p_demux->out, p_sys->es[i_es], p_block );
 
     return 1;
 }
 
+/****************************************************************************
+ * DemuxControl:
+ ****************************************************************************/
+static int DemuxControl( demux_t *p_demux, int i_query, va_list args )
+{
+   return demux2_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
+}
 
 /*****************************************************************************
  * config variable callback

modules/access/dshow/filter.cpp

@@ -299,7 +299,7 @@ int GetFourCCFromMediaType(const AM_MEDIA_TYPE &media_type)
  * Implementation of our dummy directshow filter pin class
  ****************************************************************************/
 
-CapturePin::CapturePin( input_thread_t * _p_input, CaptureFilter *_p_filter,
+CapturePin::CapturePin( access_t * _p_input, CaptureFilter *_p_filter,
                         AM_MEDIA_TYPE *mt, size_t mt_count )
   : p_input( _p_input ), p_filter( _p_filter ), p_connected_pin( NULL ),
     media_types(mt), media_type_count(mt_count), i_ref( 1 )
@@ -328,7 +328,7 @@ HRESULT CapturePin::CustomGetSample( VLCMediaSample *vlc_sample )
     msg_Dbg( p_input, "CapturePin::CustomGetSample" );
 #endif
 
-    access_sys_t *p_sys = p_input->p_access_data;
+    access_sys_t *p_sys = p_input->p_sys;
     vlc_mutex_lock( &p_sys->lock );
     if( samples_queue.size() )
     {
@@ -473,7 +473,7 @@ STDMETHODIMP CapturePin::Disconnect()
 
 #if 0 // FIXME: This does seem to create crashes sometimes
     VLCMediaSample vlc_sample;
-    access_sys_t *p_sys = p_input->p_access_data;
+    access_sys_t *p_sys = p_input->p_sys;
 
     vlc_mutex_lock( &p_sys->lock );
     while( samples_queue.size() )
@@ -660,7 +660,7 @@ STDMETHODIMP CapturePin::Receive( IMediaSample *pSample )
     mtime_t i_timestamp = mdate() * 10;
     VLCMediaSample vlc_sample = {pSample, i_timestamp};
 
-    access_sys_t *p_sys = p_input->p_access_data;
+    access_sys_t *p_sys = p_input->p_sys;
     vlc_mutex_lock( &p_sys->lock );
     samples_queue.push_front( vlc_sample );
 
@@ -705,9 +705,10 @@ STDMETHODIMP CapturePin::ReceiveCanBlock( void )
 /****************************************************************************
  * Implementation of our dummy directshow filter class
  ****************************************************************************/
-
-CaptureFilter::CaptureFilter( input_thread_t * _p_input, AM_MEDIA_TYPE *mt, size_t mt_count )
-  : p_input( _p_input ), p_pin( new CapturePin( _p_input, this, mt, mt_count ) ),
+CaptureFilter::CaptureFilter( access_t * _p_input, AM_MEDIA_TYPE *mt,
+                              size_t mt_count )
+  : p_input( _p_input ),
+    p_pin( new CapturePin( _p_input, this, mt, mt_count ) ),
     state( State_Stopped ), i_ref( 1 )
 {
 }
@@ -909,7 +910,7 @@ CapturePin *CaptureFilter::CustomGetPin()
  * Implementation of our dummy directshow enumpins class
  ****************************************************************************/
 
-CaptureEnumPins::CaptureEnumPins( input_thread_t * _p_input,
+CaptureEnumPins::CaptureEnumPins( access_t * _p_input,
                                   CaptureFilter *_p_filter,
                                   CaptureEnumPins *pEnumPins )
   : p_input( _p_input ), p_filter( _p_filter ), i_ref( 1 )
@@ -1038,10 +1039,8 @@ STDMETHODIMP CaptureEnumPins::Clone( IEnumPins **ppEnum )
 /****************************************************************************
  * Implementation of our dummy directshow enummediatypes class
  ****************************************************************************/
-
-CaptureEnumMediaTypes::CaptureEnumMediaTypes( input_thread_t * _p_input,
-                                  CapturePin *_p_pin,
-                                  CaptureEnumMediaTypes *pEnumMediaTypes )
+CaptureEnumMediaTypes::CaptureEnumMediaTypes( access_t * _p_input,
+    CapturePin *_p_pin, CaptureEnumMediaTypes *pEnumMediaTypes )
   : p_input( _p_input ), p_pin( _p_pin ), i_ref( 1 )
 {
     /* Hold a reference count on our filter */

modules/access/dshow/filter.h

@@ -69,7 +69,7 @@ class CapturePin: public IPin, public IMemInputPin
 {
     friend class CaptureEnumMediaTypes;
 
-    input_thread_t *p_input;
+    access_t *p_input;
     CaptureFilter  *p_filter;
 
     IPin *p_connected_pin;
@@ -84,7 +84,7 @@ class CapturePin: public IPin, public IMemInputPin
     long i_ref;
 
   public:
-    CapturePin( input_thread_t * _p_input, CaptureFilter *_p_filter,
+    CapturePin( access_t * _p_input, CaptureFilter *_p_filter,
                 AM_MEDIA_TYPE *mt, size_t mt_count );
     virtual ~CapturePin();
 
@@ -134,7 +134,7 @@ class CaptureFilter : public IBaseFilter
 {
     friend class CapturePin;
 
-    input_thread_t *p_input;
+    access_t *p_input;
     CapturePin     *p_pin;
     IFilterGraph   *p_graph;
     //AM_MEDIA_TYPE  media_type;
@@ -143,7 +143,7 @@ class CaptureFilter : public IBaseFilter
     long i_ref;
 
   public:
-    CaptureFilter( input_thread_t * _p_input, AM_MEDIA_TYPE *mt, size_t mt_count );
+    CaptureFilter( access_t * _p_input, AM_MEDIA_TYPE *mt, size_t mt_count );
     virtual ~CaptureFilter();
 
     /* IUnknown methods */
@@ -178,14 +178,14 @@ class CaptureFilter : public IBaseFilter
  ****************************************************************************/
 class CaptureEnumPins : public IEnumPins
 {
-    input_thread_t * p_input;
+    access_t * p_input;
     CaptureFilter  *p_filter;
 
     int i_position;
     long i_ref;
 
 public:
-    CaptureEnumPins( input_thread_t * _p_input, CaptureFilter *_p_filter,
+    CaptureEnumPins( access_t * _p_input, CaptureFilter *_p_filter,
                      CaptureEnumPins *pEnumPins );
     virtual ~CaptureEnumPins();
 
@@ -206,14 +206,14 @@ public:
  ****************************************************************************/
 class CaptureEnumMediaTypes : public IEnumMediaTypes
 {
-    input_thread_t * p_input;
+    access_t * p_input;
     CapturePin     *p_pin;
 
     int i_position;
     long i_ref;
 
 public:
-    CaptureEnumMediaTypes( input_thread_t * _p_input, CapturePin *_p_pin,
+    CaptureEnumMediaTypes( access_t * _p_input, CapturePin *_p_pin,
                            CaptureEnumMediaTypes *pEnumMediaTypes );
 
     virtual ~CaptureEnumMediaTypes();

modules/demux/demux2.c

@@ -71,6 +71,7 @@ vlc_module_begin();
     add_shortcut( "directory" );
     add_shortcut( "wav" );
     add_shortcut( "v4l" );
+    add_shortcut( "dshow" );
 vlc_module_end();
 
 /*****************************************************************************
@@ -143,6 +144,7 @@ static int Demux2Demux( input_thread_t * p_input )
 {
     demux2_sys_t *p_sys = (demux2_sys_t*)p_input->p_demux_data;
 
+    p_sys->p_demux->b_die = p_input->b_die;
     return demux2_Demux( p_sys->p_demux );
 }