/*****************************************************************************
* 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 AM_MEDIA_TYPE EnumDeviceCaps( vlc_object_t *, IBaseFilter *,
- int, int, int, int, int, int );
-static bool ConnectFilters( vlc_object_t *, IBaseFilter *, CaptureFilter * );
+static size_t EnumDeviceCaps( vlc_object_t *, IBaseFilter *,
+ int, int, int, int, int, int,
+ AM_MEDIA_TYPE *mt, size_t );
+static bool ConnectFilters( access_t *, IBaseFilter *, CaptureFilter * );
static int FindDevicesCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
/* 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
/*
* u8 data
*/
-static void SetDWBE( uint8_t *p, uint32_t dw )
-{
- p[0] = (dw >> 24)&0xff;
- p[1] = (dw >> 16)&0xff;
- p[2] = (dw >> 8)&0xff;
- p[3] = (dw )&0xff;
-}
-
-static void SetQWBE( uint8_t *p, uint64_t qw )
-{
- SetDWBE( p, (qw >> 32)&0xffffffff );
- SetDWBE( &p[4], qw&0xffffffff );
-}
-
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define CACHING_TEXT N_("Caching value in ms")
#define CACHING_LONGTEXT N_( \
- "Allows you to modify the default caching value for directshow streams. " \
+ "Allows you to modify the default caching value for DirectShow streams. " \
"This value should be set in milliseconds units." )
#define VDEV_TEXT N_("Video device name")
#define VDEV_LONGTEXT N_( \
static void DemuxClose ( vlc_object_t * );
vlc_module_begin();
+ set_shortname( _("DirectShow") );
set_description( _("DirectShow input") );
add_integer( "dshow-caching", (mtime_t)(0.2*CLOCK_FREQ) / 1000, NULL,
CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
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();
CaptureFilter *p_capture_filter;
AM_MEDIA_TYPE mt;
int i_fourcc;
- vlc_bool_t b_invert;
union
{
****************************************************************************/
#define MAX_CROSSBAR_DEPTH 10
-typedef struct CrossbarRouteRec {
+typedef struct CrossbarRouteRec
+{
IAMCrossbar *pXbar;
LONG VideoInputIndex;
LONG VideoOutputIndex;
LONG AudioInputIndex;
LONG AudioOutputIndex;
+
} CrossbarRoute;
struct access_sys_t
{
+ /* These 2 must be left at the beginning */
vlc_mutex_t lock;
vlc_cond_t wait;
int i_current_stream;
/* misc properties */
+ int i_mtu;
int i_width;
int i_height;
int i_chroma;
}
}
-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 );
}
free( p_sys->pp_streams );
free( p_sys );
-
- p_input->p_access_data = NULL;
}
/*****************************************************************************
*****************************************************************************/
static int AccessOpen( vlc_object_t *p_this )
{
- input_thread_t *p_input = (input_thread_t *)p_this;
- access_sys_t *p_sys;
- vlc_value_t val;
+ access_t *p_access = (access_t*)p_this;
+ access_sys_t *p_sys;
+ vlc_value_t val;
/* Get/parse options and open device(s) */
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" ) )
{
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],
}
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 );
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;
/* 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++ )
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 %ld to video input %ld", i, VideoOutputIndex,
+ VideoInputIndex );
if( AudioOutputIndex != -1 && AudioInputIndex != -1 )
{
if( SUCCEEDED( pXbar->Route(AudioOutputIndex,
AudioInputIndex)) )
{
- msg_Dbg(p_input, "Crossbar at depth %d, Routed audio "
- "ouput %d to audio input %d", i,
+ msg_Dbg(p_access, "Crossbar at depth %d, Routed audio "
+ "ouput %ld to audio input %ld", i,
AudioOutputIndex, AudioInputIndex );
}
}
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();
*****************************************************************************/
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:
+ case ACCESS_SET_PRIVATE_ID_STATE:
+ return VLC_EGENERIC;
+
+ default:
+ msg_Warn( p_access, "unimplemented query in control" );
+ return VLC_EGENERIC;
+
+ }
+ return VLC_SUCCESS;
}
/****************************************************************************
/****************************************************************************
* 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;
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) )
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 %ld (type %ld)", depth,
outputPinIndex, outputPinPhysicalType, inputPinIndex,
inputPinPhysicalType );
/****************************************************************************
* 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();
if( guid == PIN_CATEGORY_ANALOGVIDEOIN )
{
// recursively search crossbar routes
- FindCrossbarRoutes( p_this, pP,
+ FindCrossbarRoutes( p_access, pP,
PhysConn_Video_Tuner );
// found it
Found = TRUE;
}
}
-static int OpenDevice( input_thread_t *p_input, string devicename,
+/*
+** get fourcc priority from arbritary preference, the higher the better
+*/
+static int GetFourCCPriority(int i_fourcc)
+{
+ switch( i_fourcc )
+ {
+ case VLC_FOURCC('I','4','2','0'):
+ case VLC_FOURCC('f','l','3','2'):
+ {
+ return 9;
+ }
+
+ case VLC_FOURCC('Y','V','1','2'):
+ case VLC_FOURCC('a','r','a','w'):
+ {
+ return 8;
+ }
+
+ case VLC_FOURCC('R','V','2','4'):
+ {
+ return 7;
+ }
+
+ case VLC_FOURCC('Y','U','Y','2'):
+ case VLC_FOURCC('R','V','3','2'):
+ case VLC_FOURCC('R','G','B','A'):
+ {
+ return 6;
+ }
+ }
+ return 0;
+}
+
+#define MAX_MEDIA_TYPES 32
+
+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++ )
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 )
// 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", 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_type =
- EnumDeviceCaps( (vlc_object_t *)p_input, p_device_filter,
- p_sys->i_chroma, p_sys->i_width, p_sys->i_height,
- 0, 0, 0 );
+ AM_MEDIA_TYPE *mt;
+ AM_MEDIA_TYPE media_types[MAX_MEDIA_TYPES];
+
+ 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( mt_count > 0 )
+ {
+ mt = (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
+
+ // 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]));
+ size_t slot_copy = c;
+ for( size_t d=c+1; d<mt_count; d++ )
+ {
+ int priority =
+ GetFourCCPriority(GetFourCCFromMediaType(media_types[d]));
+ if( priority > slot_priority )
+ {
+ slot_priority = priority;
+ slot_copy = d;
+ }
+ }
+ if( slot_copy != c )
+ {
+ mt[c] = media_types[slot_copy];
+ media_types[slot_copy] = media_types[c];
+ }
+ else
+ {
+ mt[c] = media_types[c];
+ }
+ }
+ }
+ else if( ! b_audio ) {
+ // Use default video media type
+ AM_MEDIA_TYPE mtr;
+ VIDEOINFOHEADER vh;
+
+ mtr.majortype = MEDIATYPE_Video;
+ mtr.subtype = MEDIASUBTYPE_I420;
+ mtr.bFixedSizeSamples = TRUE;
+ mtr.bTemporalCompression = FALSE;
+ mtr.lSampleSize = 0;
+ mtr.pUnk = NULL;
+ mtr.formattype = FORMAT_VideoInfo;
+ mtr.cbFormat = sizeof(vh);
+ mtr.pbFormat = (BYTE *)&vh;
+
+ memset(&vh, 0, sizeof(vh));
+
+ vh.bmiHeader.biSize = sizeof(vh.bmiHeader);
+ vh.bmiHeader.biWidth = p_sys->i_width > 0 ? p_sys->i_width: 320;
+ vh.bmiHeader.biHeight = p_sys->i_height > 0 ? p_sys->i_height : 240;
+ vh.bmiHeader.biPlanes = 1;
+ vh.bmiHeader.biBitCount = 24;
+ vh.bmiHeader.biCompression = VLC_FOURCC('I','4','2','0');
+ vh.bmiHeader.biSizeImage = p_sys->i_width * 24 * p_sys->i_height / 8;
+
+ msg_Warn( p_access, "device %s using built-in video media type",
+ devicename.c_str() );
+
+ mt_count = 1;
+ mt = (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
+ CopyMediaType(mt, &mtr);
+ }
+ else {
+ // Use default audio media type
+ AM_MEDIA_TYPE mtr;
+ WAVEFORMATEX wf;
+
+ mtr.majortype = MEDIATYPE_Audio;
+ mtr.subtype = MEDIASUBTYPE_PCM;
+ mtr.bFixedSizeSamples = TRUE;
+ mtr.bTemporalCompression = FALSE;
+ mtr.lSampleSize = 0;
+ mtr.pUnk = NULL;
+ mtr.formattype = FORMAT_WaveFormatEx;
+ mtr.cbFormat = sizeof(wf);
+ mtr.pbFormat = (BYTE *)&wf;
+
+ memset(&wf, 0, sizeof(wf));
+
+ wf.wFormatTag = WAVE_FORMAT_PCM;
+ wf.nChannels = 2;
+ wf.nSamplesPerSec = 44100;
+ wf.wBitsPerSample = 16;
+ wf.nBlockAlign = wf.nSamplesPerSec * wf.wBitsPerSample / 8;
+ wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+ wf.cbSize = 0;
+
+ msg_Warn( p_access, "device %s using built-in audio media type",
+ devicename.c_str() );
+
+ mt_count = 1;
+ mt = (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
+ CopyMediaType(mt, &mtr);
+ }
/* Create and add our capture filter */
- CaptureFilter *p_capture_filter = new CaptureFilter( p_input, media_type );
+ 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
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;
dshow_stream.b_pts = VLC_FALSE;
dshow_stream.mt =
p_capture_filter->CustomGetPin()->CustomGetMediaType();
/* 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 ||
- dshow_stream.mt.formattype == FORMAT_WaveFormatEx);
+ dshow_stream.mt.majortype == MEDIATYPE_Audio );
}
dshow_stream.mt =
p_capture_filter->CustomGetPin()->CustomGetMediaType();
- if( dshow_stream.mt.majortype == MEDIATYPE_Video )
+ dshow_stream.i_fourcc = GetFourCCFromMediaType(dshow_stream.mt);
+ if( 0 != dshow_stream.i_fourcc )
{
- msg_Dbg( p_input, "MEDIATYPE_Video");
-
- /* Packed RGB formats */
- if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB1 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '1' );
- if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB4 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '4' );
- if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB8 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'G', 'B', '8' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB555 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'V', '1', '5' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB565 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'V', '1', '6' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB24 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'V', '2', '4' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_RGB32 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'V', '3', '2' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_ARGB32 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'R', 'G', 'B', 'A' );
-
- /* Packed YUV formats */
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_YVYU )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', 'V', 'Y', 'U' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_YUYV )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', 'V' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_Y411 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'I', '4', '1', 'N' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_Y211 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', '2', '1', '1' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_YUY2 ||
- dshow_stream.mt.subtype == MEDIASUBTYPE_UYVY )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', '2' );
-
- /* Planar YUV formats */
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_I420 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'I', '4', '2', '0' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_Y41P )
- dshow_stream.i_fourcc = VLC_FOURCC( 'I', '4', '1', '1' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_YV12 ||
- dshow_stream.mt.subtype == MEDIASUBTYPE_IYUV )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', 'V', '1', '2' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_YVU9 )
- dshow_stream.i_fourcc = VLC_FOURCC( 'Y', 'V', 'U', '9' );
-
- /* DV formats */
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_dvsl )
- dshow_stream.i_fourcc = VLC_FOURCC( 'd', 'v', 's', 'l' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_dvsd )
- dshow_stream.i_fourcc = VLC_FOURCC( 'd', 'v', 's', 'd' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_dvhd )
- dshow_stream.i_fourcc = VLC_FOURCC( 'd', 'v', 'h', 'd' );
-
- /* MPEG video formats */
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_MPEG2_VIDEO )
- dshow_stream.i_fourcc = VLC_FOURCC( 'm', 'p', '2', 'v' );
-
- else goto fail;
-
- dshow_stream.header.video =
- *(VIDEOINFOHEADER *)dshow_stream.mt.pbFormat;
-
- 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.mt.majortype == MEDIATYPE_Video )
{
- if( i_height > 0 ) dshow_stream.b_invert = VLC_TRUE;
- else i_height = - i_height;
- }
+ dshow_stream.header.video =
+ *(VIDEOINFOHEADER *)dshow_stream.mt.pbFormat;
- /* 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' ) )
- {
- p_input->pf_read = ReadCompressed;
- if( !p_input->psz_demux || !*p_input->psz_demux )
+ int i_height = dshow_stream.header.video.bmiHeader.biHeight;
+
+ if( !dshow_stream.header.video.bmiHeader.biCompression )
{
- p_input->psz_demux = "rawdv";
+ /* RGB DIB are coded from bottom to top */
+ i_height = - i_height;
}
- 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' ) )
- {
- p_input->pf_read = ReadCompressed;
- if( !p_input->psz_demux || !*p_input->psz_demux )
+ /* 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') )
{
- p_input->psz_demux = "mpgv";
+ p_access->pf_read = ReadCompressed;
+ if( !p_access->psz_demux || !*p_access->psz_demux )
+ {
+ p_access->psz_demux = strdup( "rawdv" );
+ }
+ p_sys->b_audio = VLC_FALSE;
}
- p_sys->b_audio = VLC_FALSE;
- }
- /* Add video stream to header */
- p_sys->i_header_size += 20;
- p_sys->p_header = (uint8_t *)realloc( p_sys->p_header,
- p_sys->i_header_size );
- memcpy( &p_sys->p_header[p_sys->i_header_pos], "vids", 4 );
- memcpy( &p_sys->p_header[p_sys->i_header_pos + 4],
- &dshow_stream.i_fourcc, 4 );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 8],
- dshow_stream.header.video.bmiHeader.biWidth );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 12], i_height );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 16], 0 );
- p_sys->i_header_pos = p_sys->i_header_size;
-
- /* 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 );
- }
+ /* Check if we are dealing with an MPEG video stream */
+ if( dshow_stream.i_fourcc == VLC_FOURCC('m','p','2','v') )
+ {
+ p_access->pf_read = ReadCompressed;
+ if( !p_access->psz_demux || !*p_access->psz_demux )
+ {
+ p_access->psz_demux = "mpgv";
+ }
+ p_sys->b_audio = VLC_FALSE;
+ }
- else if( dshow_stream.mt.majortype == MEDIATYPE_Audio &&
- dshow_stream.mt.formattype == FORMAT_WaveFormatEx )
- {
- msg_Dbg( p_input, "MEDIATYPE_Audio");
-
- if( dshow_stream.mt.subtype == MEDIASUBTYPE_PCM )
- dshow_stream.i_fourcc = VLC_FOURCC( 'a', 'r', 'a', 'w' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_IEEE_FLOAT )
- dshow_stream.i_fourcc = VLC_FOURCC( 'f', 'l', '3', '2' );
- else goto fail;
-
- dshow_stream.header.audio =
- *(WAVEFORMATEX *)dshow_stream.mt.pbFormat;
-
- /* Add audio stream to header */
- p_sys->i_header_size += 20;
- p_sys->p_header = (uint8_t *)realloc( p_sys->p_header,
- p_sys->i_header_size );
- memcpy( &p_sys->p_header[p_sys->i_header_pos], "auds", 4 );
- memcpy( &p_sys->p_header[p_sys->i_header_pos + 4],
- &dshow_stream.i_fourcc, 4 );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 8],
- dshow_stream.header.audio.nChannels );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 12],
- dshow_stream.header.audio.nSamplesPerSec );
- SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 16],
- dshow_stream.header.audio.wBitsPerSample );
- p_sys->i_header_pos = p_sys->i_header_size;
-
- /* Greatly simplifies the reading routine */
- IAMBufferNegotiation *p_ambuf;
- IPin *p_pin;
- int i_mtu;
-
- p_capture_filter->CustomGetPin()->ConnectedTo( &p_pin );
- if( SUCCEEDED( p_pin->QueryInterface(
- IID_IAMBufferNegotiation, (void **)&p_ambuf ) ) )
- {
- ALLOCATOR_PROPERTIES AllocProp;
- memset( &AllocProp, 0, sizeof( ALLOCATOR_PROPERTIES ) );
- p_ambuf->GetAllocatorProperties( &AllocProp );
- p_ambuf->Release();
- i_mtu = AllocProp.cbBuffer;
+ /* Add video stream to header */
+ p_sys->i_header_size += 20;
+ p_sys->p_header = (uint8_t *)realloc( p_sys->p_header,
+ p_sys->i_header_size );
+ memcpy( &p_sys->p_header[p_sys->i_header_pos], "vids", 4 );
+ memcpy( &p_sys->p_header[p_sys->i_header_pos + 4],
+ &dshow_stream.i_fourcc, 4 );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 8],
+ dshow_stream.header.video.bmiHeader.biWidth );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 12], i_height );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 16], 0 );
+ p_sys->i_header_pos = p_sys->i_header_size;
+
+ /* Greatly simplifies the reading routine */
+ int i_mtu = dshow_stream.header.video.bmiHeader.biWidth *
+ i_height * 4;
+ p_sys->i_mtu = __MAX( p_sys->i_mtu, i_mtu );
}
- else
+
+ else if( dshow_stream.mt.majortype == MEDIATYPE_Audio )
{
- /* Worst case */
- i_mtu = dshow_stream.header.audio.nSamplesPerSec *
+ dshow_stream.header.audio =
+ *(WAVEFORMATEX *)dshow_stream.mt.pbFormat;
+
+ /* Add audio stream to header */
+ p_sys->i_header_size += 20;
+ p_sys->p_header = (uint8_t *)realloc( p_sys->p_header,
+ p_sys->i_header_size );
+ memcpy( &p_sys->p_header[p_sys->i_header_pos], "auds", 4 );
+ memcpy( &p_sys->p_header[p_sys->i_header_pos + 4],
+ &dshow_stream.i_fourcc, 4 );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 8],
+ dshow_stream.header.audio.nChannels );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 12],
+ dshow_stream.header.audio.nSamplesPerSec );
+ SetDWBE( &p_sys->p_header[p_sys->i_header_pos + 16],
+ dshow_stream.header.audio.wBitsPerSample );
+ p_sys->i_header_pos = p_sys->i_header_size;
+
+ /* Greatly simplifies the reading routine */
+ IAMBufferNegotiation *p_ambuf;
+ IPin *p_pin;
+ int i_mtu;
+
+ p_capture_filter->CustomGetPin()->ConnectedTo( &p_pin );
+ if( SUCCEEDED( p_pin->QueryInterface(
+ IID_IAMBufferNegotiation, (void **)&p_ambuf ) ) )
+ {
+ ALLOCATOR_PROPERTIES AllocProp;
+ memset( &AllocProp, 0, sizeof( ALLOCATOR_PROPERTIES ) );
+ p_ambuf->GetAllocatorProperties( &AllocProp );
+ p_ambuf->Release();
+ i_mtu = AllocProp.cbBuffer;
+ }
+ else
+ {
+ /* Worst case */
+ i_mtu = dshow_stream.header.audio.nSamplesPerSec *
dshow_stream.header.audio.nChannels *
dshow_stream.header.audio.wBitsPerSample / 8;
+ }
+ p_pin->Release();
+ p_sys->i_mtu = __MAX( p_sys->i_mtu, i_mtu );
}
- p_pin->Release();
- p_input->i_mtu = __MAX( p_input->i_mtu, (unsigned int)i_mtu );
- }
- else if( dshow_stream.mt.majortype == MEDIATYPE_Stream )
- {
- msg_Dbg( p_input, "MEDIATYPE_Stream" );
-
- if( dshow_stream.mt.subtype == MEDIASUBTYPE_MPEG2_PROGRAM )
- dshow_stream.i_fourcc = VLC_FOURCC( 'm', 'p', '2', 'p' );
- else if( dshow_stream.mt.subtype == MEDIASUBTYPE_MPEG2_TRANSPORT )
- dshow_stream.i_fourcc = VLC_FOURCC( 'm', 'p', '2', 't' );
-
- msg_Dbg( p_input, "selected stream pin accepts format: %4.4s",
- (char *)&dshow_stream.i_fourcc);
+ else if( dshow_stream.mt.majortype == MEDIATYPE_Stream )
+ {
+ msg_Dbg( p_access, "MEDIATYPE_Stream" );
- 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;
+ msg_Dbg( p_access, "selected stream pin accepts format: %4.4s",
+ (char *)&dshow_stream.i_fourcc);
- p_input->pf_read = ReadCompressed;
- p_input->pf_set_program = input_SetProgram;
- }
+ p_sys->b_audio = VLC_FALSE;
+ p_sys->i_header_size = 0;
+ p_sys->i_header_pos = 0;
+ p_sys->i_mtu = 0;
- else
- {
- msg_Dbg( p_input, "unknown stream majortype" );
- goto fail;
- }
+ p_access->pf_read = ReadCompressed;
+ }
+ else
+ {
+ msg_Dbg( p_access, "unknown stream majortype" );
+ goto fail;
+ }
- /* Add directshow elementary stream to our list */
- dshow_stream.p_device_filter = p_device_filter;
- dshow_stream.p_capture_filter = p_capture_filter;
+ /* Add directshow elementary stream to our list */
+ 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[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 );
+ 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 );
- return VLC_SUCCESS;
+ return VLC_SUCCESS;
+ }
}
fail:
IID_ICreateDevEnum, (void **)&p_dev_enum );
if( FAILED(hr) )
{
- msg_Err( p_this, "failed to create the device enumerator (0x%x)", hr);
+ msg_Err( p_this, "failed to create the device enumerator (0x%lx)", hr);
return NULL;
}
p_dev_enum->Release();
if( FAILED(hr) )
{
- msg_Err( p_this, "failed to create the class enumerator (0x%x)", hr );
+ msg_Err( p_this, "failed to create the class enumerator (0x%lx)", hr );
return NULL;
}
if( FAILED(hr) )
{
msg_Err( p_this, "couldn't bind moniker to filter "
- "object (0x%x)", hr );
+ "object (0x%lx)", hr );
p_moniker->Release();
p_class_enum->Release();
return NULL;
return NULL;
}
-static AM_MEDIA_TYPE 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 )
+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 )
{
IEnumPins *p_enumpins;
IPin *p_output_pin;
IEnumMediaTypes *p_enummt;
- int i_orig_fourcc = i_fourcc;
- vlc_bool_t b_found = VLC_FALSE;
+ size_t mt_count = 0;
- AM_MEDIA_TYPE media_type;
- media_type.majortype = GUID_NULL;
- media_type.subtype = GUID_NULL;
- media_type.formattype = GUID_NULL;
- media_type.pUnk = NULL;
- media_type.cbFormat = 0;
- media_type.pbFormat = NULL;
-
- if( S_OK != p_filter->EnumPins( &p_enumpins ) ) return media_type;
+ if( FAILED(p_filter->EnumPins( &p_enumpins )) )
+ {
+ msg_Dbg( p_this, "EnumDeviceCaps failed: no pin enumeration !");
+ return 0;
+ }
while( S_OK == p_enumpins->Next( 1, &p_output_pin, NULL ) )
{
p_output_pin->Release();
}
+
p_enumpins->Reset();
- while( !b_found && 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;
AM_MEDIA_TYPE *p_mt;
while( p_enummt->Next( 1, &p_mt, NULL ) == S_OK )
{
-
- if( p_mt->majortype == MEDIATYPE_Video )
- {
- int i_current_fourcc = VLC_FOURCC(' ', ' ', ' ', ' ');
-
- /* Packed RGB formats */
- if( p_mt->subtype == MEDIASUBTYPE_RGB1 )
- i_current_fourcc = VLC_FOURCC( 'R', 'G', 'B', '1' );
- if( p_mt->subtype == MEDIASUBTYPE_RGB4 )
- i_current_fourcc = VLC_FOURCC( 'R', 'G', 'B', '4' );
- if( p_mt->subtype == MEDIASUBTYPE_RGB8 )
- i_current_fourcc = VLC_FOURCC( 'R', 'G', 'B', '8' );
- else if( p_mt->subtype == MEDIASUBTYPE_RGB555 )
- i_current_fourcc = VLC_FOURCC( 'R', 'V', '1', '5' );
- else if( p_mt->subtype == MEDIASUBTYPE_RGB565 )
- i_current_fourcc = VLC_FOURCC( 'R', 'V', '1', '6' );
- else if( p_mt->subtype == MEDIASUBTYPE_RGB24 )
- i_current_fourcc = VLC_FOURCC( 'R', 'V', '2', '4' );
- else if( p_mt->subtype == MEDIASUBTYPE_RGB32 )
- i_current_fourcc = VLC_FOURCC( 'R', 'V', '3', '2' );
- else if( p_mt->subtype == MEDIASUBTYPE_ARGB32 )
- i_current_fourcc = VLC_FOURCC( 'R', 'G', 'B', 'A' );
-
- /* Packed YUV formats */
- else if( p_mt->subtype == MEDIASUBTYPE_YVYU )
- i_current_fourcc = VLC_FOURCC( 'Y', 'V', 'Y', 'U' );
- else if( p_mt->subtype == MEDIASUBTYPE_YUYV )
- i_current_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', 'V' );
- else if( p_mt->subtype == MEDIASUBTYPE_Y411 )
- i_current_fourcc = VLC_FOURCC( 'I', '4', '1', 'N' );
- else if( p_mt->subtype == MEDIASUBTYPE_Y211 )
- i_current_fourcc = VLC_FOURCC( 'Y', '2', '1', '1' );
- else if( p_mt->subtype == MEDIASUBTYPE_YUY2 ||
- p_mt->subtype == MEDIASUBTYPE_UYVY )
- i_current_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', '2' );
-
- /* MPEG2 video elementary stream */
- else if( p_mt->subtype == MEDIASUBTYPE_MPEG2_VIDEO )
- i_current_fourcc = VLC_FOURCC( 'm', 'p', '2', 'v' );
-
- /* hauppauge pvr video preview */
- else if( p_mt->subtype == MEDIASUBTYPE_PREVIEW_VIDEO )
- i_current_fourcc = VLC_FOURCC( 'P', 'V', 'R', 'V' );
-
- else i_current_fourcc = *((int *)&p_mt->subtype);
-
- int i_current_width = p_mt->pbFormat ?
- ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biWidth : 0;
- int i_current_height = p_mt->pbFormat ?
- ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biHeight : 0;
- if( i_current_height < 0 )
- i_current_height = -i_current_height;
-
- msg_Dbg( p_this, "EnumDeviceCaps: input pin "
- "accepts chroma: %4.4s, width:%i, height:%i",
- (char *)&i_current_fourcc, i_current_width,
- i_current_height );
-
- if( ( !i_fourcc || i_fourcc == i_current_fourcc ||
- ( !i_orig_fourcc && i_current_fourcc ==
- VLC_FOURCC('I','4','2','0') ) ) &&
- ( !i_width || i_width == i_current_width ) &&
- ( !i_height || i_height == i_current_height ) )
- {
- /* Pick the 1st match */
- media_type = *p_mt;
- i_fourcc = i_current_fourcc;
- i_width = i_current_width;
- i_height = i_current_height;
- b_found = VLC_TRUE;
- }
- else
- {
- FreeMediaType( *p_mt );
- }
- }
- else if( p_mt->majortype == MEDIATYPE_Audio )
+ int i_current_fourcc = GetFourCCFromMediaType(*p_mt);
+ if( 0 != i_current_fourcc )
{
- int i_current_fourcc;
- int i_current_channels =
- ((WAVEFORMATEX *)p_mt->pbFormat)->nChannels;
- int i_current_samplespersec =
- ((WAVEFORMATEX *)p_mt->pbFormat)->nSamplesPerSec;
- int i_current_bitspersample =
- ((WAVEFORMATEX *)p_mt->pbFormat)->wBitsPerSample;
-
- if( p_mt->subtype == MEDIASUBTYPE_PCM )
- i_current_fourcc = VLC_FOURCC( 'p', 'c', 'm', ' ' );
- else i_current_fourcc = *((int *)&p_mt->subtype);
-
- msg_Dbg( p_this, "EnumDeviceCaps: input pin "
- "accepts format: %4.4s, channels:%i, "
- "samples/sec:%i bits/sample:%i",
- (char *)&i_current_fourcc, i_current_channels,
- i_current_samplespersec, i_current_bitspersample);
-
- if( (!i_channels || i_channels == i_current_channels) &&
- (!i_samplespersec ||
- i_samplespersec == i_current_samplespersec) &&
- (!i_bitspersample ||
- i_bitspersample == i_current_bitspersample) )
+ if( p_mt->majortype == MEDIATYPE_Video )
{
- /* Pick the 1st match */
- media_type = *p_mt;
- i_channels = i_current_channels;
- i_samplespersec = i_current_samplespersec;
- i_bitspersample = i_current_bitspersample;
- b_found = VLC_TRUE;
-
- /* Setup a few properties like the audio latency */
- IAMBufferNegotiation *p_ambuf;
-
- if( SUCCEEDED( p_output_pin->QueryInterface(
- IID_IAMBufferNegotiation, (void **)&p_ambuf ) ) )
+ int i_current_width = p_mt->pbFormat ?
+ ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biWidth : 0;
+ int i_current_height = p_mt->pbFormat ?
+ ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biHeight : 0;
+ if( i_current_height < 0 )
+ i_current_height = -i_current_height;
+
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin "
+ "accepts chroma: %4.4s, width:%i, height:%i",
+ (char *)&i_current_fourcc, i_current_width,
+ i_current_height );
+
+ if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
+ ( !i_width || i_width == i_current_width ) &&
+ ( !i_height || i_height == i_current_height ) &&
+ (mt_count < mt_max) )
{
- ALLOCATOR_PROPERTIES AllocProp;
- AllocProp.cbAlign = -1;
- AllocProp.cbBuffer = i_channels * i_samplespersec *
- i_bitspersample / 8 / 10 ; /*100 ms of latency*/
- AllocProp.cbPrefix = -1;
- AllocProp.cBuffers = -1;
- p_ambuf->SuggestAllocatorProperties( &AllocProp );
- p_ambuf->Release();
+ /* Pick match */
+ mt[mt_count++] = *p_mt;
+ }
+ else
+ {
+ FreeMediaType( *p_mt );
}
}
- else
+ else if( p_mt->majortype == MEDIATYPE_Audio )
{
- FreeMediaType( *p_mt );
- }
- }
- else if( p_mt->majortype == MEDIATYPE_Stream )
- {
- msg_Dbg( p_this, "EnumDeviceCaps: MEDIATYPE_Stream" );
-
- int i_current_fourcc = VLC_FOURCC(' ', ' ', ' ', ' ');
+ int i_current_channels =
+ ((WAVEFORMATEX *)p_mt->pbFormat)->nChannels;
+ int i_current_samplespersec =
+ ((WAVEFORMATEX *)p_mt->pbFormat)->nSamplesPerSec;
+ int i_current_bitspersample =
+ ((WAVEFORMATEX *)p_mt->pbFormat)->wBitsPerSample;
+
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin "
+ "accepts format: %4.4s, channels:%i, "
+ "samples/sec:%i bits/sample:%i",
+ (char *)&i_current_fourcc, i_current_channels,
+ i_current_samplespersec, i_current_bitspersample);
+
+ if( (!i_channels || i_channels == i_current_channels) &&
+ (!i_samplespersec ||
+ i_samplespersec == i_current_samplespersec) &&
+ (!i_bitspersample ||
+ i_bitspersample == i_current_bitspersample) &&
+ (mt_count < mt_max) )
+ {
+ /* Pick match */
+ mt[mt_count++] = *p_mt;
- if( p_mt->subtype == MEDIASUBTYPE_MPEG2_PROGRAM )
- i_current_fourcc = VLC_FOURCC( 'm', 'p', '2', 'p' );
- else if( p_mt->subtype == MEDIASUBTYPE_MPEG2_TRANSPORT )
- i_current_fourcc = VLC_FOURCC( 'm', 'p', '2', 't' );
+ /* Pre-Configure the 1st match, Ugly */
+ if( 1 == mt_count ) {
+ /* Setup a few properties like the audio latency */
+ IAMBufferNegotiation *p_ambuf;
- if( ( !i_fourcc || i_fourcc == i_current_fourcc ) )
+ if( SUCCEEDED( p_output_pin->QueryInterface(
+ IID_IAMBufferNegotiation, (void **)&p_ambuf ) ) )
+ {
+ ALLOCATOR_PROPERTIES AllocProp;
+ AllocProp.cbAlign = -1;
+ AllocProp.cbBuffer = i_current_channels *
+ i_current_samplespersec *
+ i_current_bitspersample / 8 / 10 ; /*100 ms of latency*/
+ AllocProp.cbPrefix = -1;
+ AllocProp.cBuffers = -1;
+ p_ambuf->SuggestAllocatorProperties( &AllocProp );
+ p_ambuf->Release();
+ }
+ }
+ }
+ else
+ {
+ FreeMediaType( *p_mt );
+ }
+ }
+ else if( p_mt->majortype == MEDIATYPE_Stream )
{
- /* Pick the 1st match */
- media_type = *p_mt;
- i_fourcc = i_current_fourcc;
- b_found = VLC_TRUE;
+ if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
+ (mt_count < mt_max) )
+ {
+ /* Pick match */
+ mt[mt_count++] = *p_mt;
+ i_fourcc = i_current_fourcc;
+ }
+ else
+ {
+ FreeMediaType( *p_mt );
+ }
}
else
{
+ msg_Dbg( p_this,
+ "EnumDeviceCaps: input pin: unknown format" );
FreeMediaType( *p_mt );
}
}
else
{
msg_Dbg( p_this,
- "EnumDeviceCaps: input pin: unknown format" );
+ "EnumDeviceCaps: input pin: unknown format" );
FreeMediaType( *p_mt );
}
-
CoTaskMemFree( (PVOID)p_mt );
}
p_enummt->Release();
}
p_enumpins->Release();
- return media_type;
+ return mt_count;
}
/*****************************************************************************
- * 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;
}
#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 */
p_buffer += 16 /* header size */;
/* 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_buffer += i_data_size;
- }
- else
- {
- int i_width = p_stream->header.video.bmiHeader.biWidth;
- int i_height = p_stream->header.video.bmiHeader.biHeight;
- if( i_height < 0 ) i_height = - i_height;
-
- switch( p_stream->i_fourcc )
- {
- case VLC_FOURCC( 'R', 'V', '1', '5' ):
- case VLC_FOURCC( 'R', 'V', '1', '6' ):
- i_width *= 2;
- break;
- case VLC_FOURCC( 'R', 'V', '2', '4' ):
- i_width *= 3;
- break;
- case VLC_FOURCC( 'R', 'V', '3', '2' ):
- case VLC_FOURCC( 'R', 'G', 'B', 'A' ):
- i_width *= 4;
- break;
- }
-
- for( int i = i_height - 1; i >= 0; i-- )
- {
- p_input->p_vlc->pf_memcpy( p_buffer,
- &p_data[i * i_width], i_width );
-
- p_buffer += i_width;
- }
- }
+ p_access->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
+ p_buffer += i_data_size;
sample.p_sample->Release();
* 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;
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 );
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();
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_sys_t *p_sys;
+ demux_t *p_demux = (demux_t *)p_this;
+ demux_sys_t *p_sys;
- uint8_t *p_peek;
- int i_es;
- int i;
+ uint8_t *p_peek;
+ int i_es;
+ 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)" );
+ msg_Warn( p_demux, "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" );
- 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;
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 ) )
{
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;
}
****************************************************************************/
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 )
{
/****************************************************************************
* 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] );
+ 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
projects / vlc / blobdiff