/*****************************************************************************
* dshow.cpp : DirectShow access module for vlc
*****************************************************************************
- * Copyright (C) 2002, 2003 VideoLAN
+ * Copyright (C) 2002, 2003 the VideoLAN team
* $Id$
*
* Author: Gildas Bazin <gbazin@videolan.org>
/*****************************************************************************
* Access: local prototypes
*****************************************************************************/
-static int ReadCompressed( access_t *, byte_t *, int );
+static block_t *ReadCompressed( access_t * );
static int AccessControl ( access_t *, int, va_list );
static int Demux ( demux_t * );
static int ConfigDevicesCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
-static void PropertiesPage( vlc_object_t *, IBaseFilter *,
- ICaptureGraphBuilder2 *, vlc_bool_t );
+static void ShowPropertyPage( IUnknown * );
+static void ShowDeviceProperties( vlc_object_t *, ICaptureGraphBuilder2 *,
+ IBaseFilter *, vlc_bool_t );
+static void ShowTunerProperties( vlc_object_t *, ICaptureGraphBuilder2 *,
+ IBaseFilter *, vlc_bool_t );
+static void ConfigTuner( vlc_object_t *, ICaptureGraphBuilder2 *,
+ IBaseFilter * );
/*****************************************************************************
* Module descriptor
static char *ppsz_vdev_text[] = { N_("Default"), N_("None") };
static char *ppsz_adev[] = { "", "none" };
static char *ppsz_adev_text[] = { N_("Default"), N_("None") };
+static int pi_tuner_input[] = { 0, 1, 2 };
+static char *ppsz_tuner_input_text[] =
+ {N_("Default"), N_("Cable"), N_("Antenna")};
#define CACHING_TEXT N_("Caching value in ms")
#define CACHING_LONGTEXT N_( \
#define CHROMA_LONGTEXT N_( \
"Force the DirectShow video input to use a specific chroma format " \
"(eg. I420 (default), RV24, etc.)")
+#define FPS_TEXT N_("Video input frame rate")
+#define FPS_LONGTEXT N_( \
+ "Force the DirectShow video input to use a specific frame rate" \
+ "(eg. 0 means default, 25, 29.97, 50, 59.94, etc.)")
#define CONFIG_TEXT N_("Device properties")
#define CONFIG_LONGTEXT N_( \
"Show the properties dialog of the selected device before starting the " \
"stream.")
+#define TUNER_TEXT N_("Tuner properties")
+#define TUNER_LONGTEXT N_( \
+ "Show the tuner properties [channel selection] page." )
+#define CHANNEL_TEXT N_("Tuner TV Channel")
+#define CHANNEL_LONGTEXT N_( \
+ "Allows you to set the TV channel the tuner will set to " \
+ "(0 means default)." )
+#define COUNTRY_TEXT N_("Tuner country code")
+#define COUNTRY_LONGTEXT N_( \
+ "Allows you to set the tuner country code that establishes the current " \
+ "channel-to-frequency mapping (0 means default)." )
+#define TUNER_INPUT_TEXT N_("Tuner input type")
+#define TUNER_INPUT_LONGTEXT N_( \
+ "Allows you to select the tuner input type (Cable/Antenna)." )
static int CommonOpen ( vlc_object_t *, access_sys_t *, vlc_bool_t );
static void CommonClose( vlc_object_t *, access_sys_t * );
vlc_module_begin();
set_shortname( _("DirectShow") );
set_description( _("DirectShow input") );
+ set_category( CAT_INPUT );
+ set_subcategory( SUBCAT_INPUT_ACCESS );
add_integer( "dshow-caching", (mtime_t)(0.2*CLOCK_FREQ) / 1000, NULL,
CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
add_string( "dshow-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT,
VLC_TRUE );
+ add_float( "dshow-fps", 0.0f, NULL, FPS_TEXT, FPS_LONGTEXT,
+ VLC_TRUE );
+
add_bool( "dshow-config", VLC_FALSE, NULL, CONFIG_TEXT, CONFIG_LONGTEXT,
VLC_FALSE );
+ add_bool( "dshow-tuner", VLC_FALSE, NULL, TUNER_TEXT, TUNER_LONGTEXT,
+ VLC_FALSE );
+
+ add_integer( "dshow-tuner-channel", 0, NULL, CHANNEL_TEXT,
+ CHANNEL_LONGTEXT, VLC_TRUE );
+
+ add_integer( "dshow-tuner-country", 0, NULL, COUNTRY_TEXT,
+ COUNTRY_LONGTEXT, VLC_TRUE );
+
+ add_integer( "dshow-tuner-input", 0, NULL, TUNER_INPUT_TEXT,
+ TUNER_INPUT_LONGTEXT, VLC_TRUE );
+ change_integer_list( pi_tuner_input, ppsz_tuner_input_text, 0 );
+
add_shortcut( "dshow" );
set_capability( "access_demux", 0 );
set_callbacks( DemuxOpen, DemuxClose );
int i_width = 0, i_height = 0, i_chroma = 0;
vlc_bool_t b_audio = VLC_TRUE;
- var_Create( p_this, "dshow-config", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+ var_Create( p_this, "dshow-config", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+ var_Create( p_this, "dshow-tuner", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Create( p_this, "dshow-vdev", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_this, "dshow-vdev", &val );
}
if( val.psz_string ) free( val.psz_string );
+ var_Create( p_this, "dshow-fps", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
+ var_Create( p_this, "dshow-tuner-channel",
+ VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+ var_Create( p_this, "dshow-tuner-country",
+ VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+ var_Create( p_this, "dshow-tuner-input",
+ VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+
var_Create( p_this, "dshow-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
/* Initialize OLE/COM */
/* Initialize some data */
p_sys->i_streams = 0;
- p_sys->pp_streams = (dshow_stream_t **)malloc( 1 );
+ p_sys->pp_streams = 0;
p_sys->i_width = i_width;
p_sys->i_height = i_height;
p_sys->i_chroma = i_chroma;
p_sys->p_capture_graph_builder2 = NULL;
p_sys->p_control = NULL;
+ vlc_mutex_init( p_this, &p_sys->lock );
+ vlc_cond_init( p_this, &p_sys->wait );
+
/* Build directshow graph */
CreateDirectShowGraph( p_sys );
p_stream->i_fourcc == VLC_FOURCC('m','p','2','v') )
{
b_audio = VLC_FALSE;
+
+ if( b_access_demux )
+ {
+ /* Let the access (only) take care of that */
+ return VLC_EGENERIC;
+ }
}
}
- if( p_stream->mt.majortype == MEDIATYPE_Stream ) b_audio = VLC_FALSE;
+ if( p_stream->mt.majortype == MEDIATYPE_Stream )
+ {
+ b_audio = VLC_FALSE;
+
+ if( b_access_demux )
+ {
+ /* Let the access (only) take care of that */
+ return VLC_EGENERIC;
+ }
+
+ var_Get( p_this, "dshow-tuner", &val );
+ if( val.b_bool )
+ {
+ /* FIXME: we do MEDIATYPE_Stream here so we don't do
+ * it twice. */
+ ShowTunerProperties( p_this, p_sys->p_capture_graph_builder2,
+ p_stream->p_device_filter, 0 );
+ }
+ }
}
if( b_audio && OpenDevice( p_this, p_sys, adevname, 1 ) != VLC_SUCCESS )
msg_Err( p_this, "can't open audio");
}
- for( i = 0; i < p_sys->i_crossbar_route_depth; i++ )
+ for( i = p_sys->i_crossbar_route_depth-1; i >= 0 ; --i )
{
IAMCrossbar *pXbar = p_sys->crossbar_routes[i].pXbar;
LONG VideoInputIndex = p_sys->crossbar_routes[i].VideoInputIndex;
}
}
+ /*
+ ** Show properties pages from other filters in graph
+ */
+ var_Get( p_this, "dshow-config", &val );
+ if( val.b_bool )
+ {
+ for( i = p_sys->i_crossbar_route_depth-1; i >= 0 ; --i )
+ {
+ IAMCrossbar *pXbar = p_sys->crossbar_routes[i].pXbar;
+ IBaseFilter *p_XF;
+
+ if( SUCCEEDED( pXbar->QueryInterface( IID_IBaseFilter,
+ (void **)&p_XF ) ) )
+ {
+ ShowPropertyPage( p_XF );
+ p_XF->Release();
+ }
+ }
+ }
+
/* Initialize some data */
p_sys->i_current_stream = 0;
- vlc_mutex_init( p_this, &p_sys->lock );
- vlc_cond_init( p_this, &p_sys->wait );
if( !p_sys->i_streams ) return VLC_EGENERIC;
if( p_stream->i_fourcc == VLC_FOURCC('R','V','2','4') )
{
/* This is in BGR format */
- fmt.video.i_bmask = 0x00ff0000;
- fmt.video.i_gmask = 0x0000ff00;
- fmt.video.i_rmask = 0x000000ff;
+ fmt.video.i_bmask = 0x00ff0000;
+ fmt.video.i_gmask = 0x0000ff00;
+ fmt.video.i_rmask = 0x000000ff;
+ }
+
+ if( p_stream->header.video.AvgTimePerFrame )
+ {
+ fmt.video.i_frame_rate = 10000000;
+ fmt.video.i_frame_rate_base =
+ p_stream->header.video.AvgTimePerFrame;
}
}
else if( p_stream->mt.majortype == MEDIATYPE_Audio )
p_access->p_sys = p_sys = (access_sys_t *)malloc( sizeof( access_sys_t ) );
memset( p_sys, 0, sizeof( access_sys_t ) );
- if( CommonOpen( p_this, p_sys, VLC_TRUE ) != VLC_SUCCESS )
+ if( CommonOpen( p_this, p_sys, VLC_FALSE ) != VLC_SUCCESS )
{
CommonClose( p_this, p_sys );
return VLC_EGENERIC;
}
/* Setup Access */
- p_access->pf_read = ReadCompressed;
- p_access->pf_block = NULL;
+ p_access->pf_read = NULL;
+ p_access->pf_block = ReadCompressed;
p_access->pf_control = AccessControl;
p_access->pf_seek = NULL;
p_access->info.i_update = 0;
/* Uninitialize OLE/COM */
CoUninitialize();
- /* Remove filters from graph */
- for( int i = 0; i < p_sys->i_streams; i++ )
- {
- delete p_sys->pp_streams[i];
- }
- free( p_sys->pp_streams );
+ for( int i = 0; i < p_sys->i_streams; i++ ) delete p_sys->pp_streams[i];
+ if( p_sys->i_streams ) free( p_sys->pp_streams );
vlc_mutex_destroy( &p_sys->lock );
vlc_cond_destroy( &p_sys->wait );
// Sort out all the possible video inputs
// The class needs to be given the capture filters ANALOGVIDEO input pin
IEnumPins *pins = 0;
- if( mediaType.majortype == MEDIATYPE_Video &&
+ if( ( mediaType.majortype == MEDIATYPE_Video ||
+ mediaType.majortype == MEDIATYPE_Stream ) &&
SUCCEEDED(p_filter->EnumPins(&pins)) )
{
IPin *pP = 0;
if( guid == PIN_CATEGORY_ANALOGVIDEOIN )
{
// recursively search crossbar routes
- FindCrossbarRoutes( p_this, p_sys, pP,
- PhysConn_Video_Tuner );
+ FindCrossbarRoutes( p_this, p_sys, pP, 0 );
// found it
Found = TRUE;
}
return VLC_EGENERIC;
}
- AM_MEDIA_TYPE *mt;
+ // Retreive acceptable media types supported by device
AM_MEDIA_TYPE media_types[MAX_MEDIA_TYPES];
-
- size_t mt_count = EnumDeviceCaps( p_this, 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 )
+ size_t media_count =
+ EnumDeviceCaps( p_this, p_device_filter, p_sys->i_chroma,
+ p_sys->i_width, p_sys->i_height,
+ 0, 0, 0, media_types, MAX_MEDIA_TYPES );
+
+ /* Find out if the pin handles MEDIATYPE_Stream, in which case we
+ * won't add a prefered media type as this doesn't seem to work well
+ * -- to investigate. */
+ vlc_bool_t b_stream_type = VLC_FALSE;
+ for( size_t i = 0; i < media_count; i++ )
{
- 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++ )
+ if( media_types[i].majortype == MEDIATYPE_Stream )
{
- 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];
- }
+ b_stream_type = VLC_TRUE;
+ break;
}
}
- else if( !b_audio )
+
+ size_t mt_count = 0;
+ AM_MEDIA_TYPE *mt = NULL;
+
+ if( !b_stream_type && !b_audio )
{
- // Use default video media type
+ // Insert prefered video media type
AM_MEDIA_TYPE mtr;
VIDEOINFOHEADER vh;
mtr.subtype = MEDIASUBTYPE_I420;
mtr.bFixedSizeSamples = TRUE;
mtr.bTemporalCompression = FALSE;
- mtr.lSampleSize = 0;
mtr.pUnk = NULL;
mtr.formattype = FORMAT_VideoInfo;
mtr.cbFormat = sizeof(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.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.biPlanes = 3;
vh.bmiHeader.biBitCount = 12;
vh.bmiHeader.biCompression = VLC_FOURCC('I','4','2','0');
- vh.bmiHeader.biSizeImage = p_sys->i_width * 12 * p_sys->i_height / 8;
-
- msg_Warn( p_this, "device %s using built-in video media type",
- devicename.c_str() );
+ vh.bmiHeader.biSizeImage = vh.bmiHeader.biWidth * 12 *
+ vh.bmiHeader.biHeight / 8;
+ mtr.lSampleSize = vh.bmiHeader.biSizeImage;
mt_count = 1;
mt = (AM_MEDIA_TYPE *)malloc( sizeof(AM_MEDIA_TYPE)*mt_count );
CopyMediaType(mt, &mtr);
}
- else
+ else if( !b_stream_type )
{
- // Use default audio media type
+ // Insert prefered audio media type
AM_MEDIA_TYPE mtr;
WAVEFORMATEX wf;
wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
wf.cbSize = 0;
- msg_Warn( p_this, "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);
}
+ if( media_count > 0 )
+ {
+ mt = (AM_MEDIA_TYPE *)realloc( mt, sizeof(AM_MEDIA_TYPE) *
+ (mt_count + media_count) );
+
+ // Order and copy returned media types according to arbitrary
+ // fourcc priority
+ for( size_t c = 0; c < media_count; c++ )
+ {
+ int slot_priority =
+ GetFourCCPriority(GetFourCCFromMediaType(media_types[c]));
+ size_t slot_copy = c;
+ for( size_t d = c+1; d < media_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+mt_count] = media_types[slot_copy];
+ media_types[slot_copy] = media_types[c];
+ }
+ else
+ {
+ mt[c+mt_count] = media_types[c];
+ }
+ }
+ mt_count += media_count;
+ }
+
/* Create and add our capture filter */
CaptureFilter *p_capture_filter =
new CaptureFilter( p_this, p_sys, mt, mt_count );
dshow_stream.mt =
p_capture_filter->CustomGetPin()->CustomGetMediaType();
- /* Show properties. Done here so the VLC stream is setup with the
- * proper parameters. */
+ /* Show Device properties. Done here so the VLC stream is setup with
+ * the proper parameters. */
vlc_value_t val;
var_Get( p_this, "dshow-config", &val );
- if( val.i_int )
+ if( val.b_bool )
+ {
+ ShowDeviceProperties( p_this, p_sys->p_capture_graph_builder2,
+ p_device_filter, b_audio );
+ }
+
+ ConfigTuner( p_this, p_sys->p_capture_graph_builder2,
+ p_device_filter );
+
+ var_Get( p_this, "dshow-tuner", &val );
+ if( val.b_bool && dshow_stream.mt.majortype != MEDIATYPE_Stream )
{
- PropertiesPage( p_this, p_device_filter,
- p_sys->p_capture_graph_builder2,
- dshow_stream.mt.majortype == MEDIATYPE_Audio );
+ /* FIXME: we do MEDIATYPE_Stream later so we don't do it twice. */
+ ShowTunerProperties( p_this, p_sys->p_capture_graph_builder2,
+ p_device_filter, b_audio );
}
dshow_stream.mt =
p_bag->Release();
if( SUCCEEDED(hr) )
{
- int i_convert = ( lstrlenW( var.bstrVal ) + 1 ) * 2;
- char *p_buf = (char *)alloca( i_convert ); p_buf[0] = 0;
- WideCharToMultiByte( CP_ACP, 0, var.bstrVal, -1, p_buf,
- i_convert, NULL, NULL );
+ int i_convert = WideCharToMultiByte(CP_ACP, 0, var.bstrVal,
+ SysStringLen(var.bstrVal), NULL, 0, NULL, NULL);
+ char *p_buf = (char *)alloca( i_convert+1 ); p_buf[0] = 0;
+ WideCharToMultiByte( CP_ACP, 0, var.bstrVal,
+ SysStringLen(var.bstrVal), p_buf, i_convert, NULL, NULL );
SysFreeString(var.bstrVal);
+ p_buf[i_convert] = '\0';
if( p_listdevices ) p_listdevices->push_back( p_buf );
IEnumMediaTypes *p_enummt;
size_t mt_count = 0;
+ LONGLONG i_AvgTimePerFrame = 0;
+ float r_fps = var_GetFloat( p_this, "dshow-fps" );
+ if( r_fps )
+ i_AvgTimePerFrame = 10000000000LL/(LONGLONG)(r_fps*1000.0f);
+
if( FAILED(p_filter->EnumPins( &p_enumpins )) )
{
msg_Dbg( p_this, "EnumDeviceCaps failed: no pin enumeration !");
msg_Dbg( p_this, "EnumDeviceCaps: trying pin %S", info.achName );
}
- /* Probe pin */
- if( !SUCCEEDED( p_output_pin->EnumMediaTypes( &p_enummt ) ) )
+ AM_MEDIA_TYPE *p_mt;
+
+ /*
+ ** Configure pin with a default compatible media if possible
+ */
+
+ IAMStreamConfig *pSC;
+ if( SUCCEEDED(p_output_pin->QueryInterface( IID_IAMStreamConfig,
+ (void **)&pSC )) )
+ {
+ int piCount, piSize;
+ if( SUCCEEDED(pSC->GetNumberOfCapabilities(&piCount, &piSize)) )
+ {
+ BYTE *pSCC= (BYTE *)CoTaskMemAlloc(piSize);
+ if( NULL != pSCC )
+ {
+ for( int i=0; i<piCount; ++i )
+ {
+ if( SUCCEEDED(pSC->GetStreamCaps(i, &p_mt, pSCC)) )
+ {
+ int i_current_fourcc = GetFourCCFromMediaType( *p_mt );
+
+ if( !i_current_fourcc || (i_fourcc && (i_current_fourcc != i_fourcc)) )
+ {
+ // incompatible or unrecognized chroma, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+
+ if( MEDIATYPE_Video == p_mt->majortype
+ && FORMAT_VideoInfo == p_mt->formattype )
+ {
+ VIDEO_STREAM_CONFIG_CAPS *pVSCC = reinterpret_cast<VIDEO_STREAM_CONFIG_CAPS*>(pSCC);
+ VIDEOINFOHEADER *pVih = reinterpret_cast<VIDEOINFOHEADER*>(p_mt->pbFormat);
+
+ if( i_AvgTimePerFrame )
+ {
+ if( pVSCC->MinFrameInterval > i_AvgTimePerFrame
+ || i_AvgTimePerFrame > pVSCC->MaxFrameInterval )
+ {
+ // required frame rate not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pVih->AvgTimePerFrame = i_AvgTimePerFrame;
+ }
+
+ if( i_width )
+ {
+ if( i_width % pVSCC->OutputGranularityX
+ || pVSCC->MinOutputSize.cx > i_width
+ || i_width > pVSCC->MaxOutputSize.cx )
+ {
+ // required width not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pVih->bmiHeader.biWidth = i_width;
+ }
+
+ if( i_height )
+ {
+ if( i_height % pVSCC->OutputGranularityY
+ || pVSCC->MinOutputSize.cy > i_height
+ || i_height > pVSCC->MaxOutputSize.cy )
+ {
+ // required height not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pVih->bmiHeader.biHeight = i_height;
+ }
+
+ // Set the sample size and image size.
+ // (Round the image width up to a DWORD boundary.)
+ p_mt->lSampleSize = pVih->bmiHeader.biSizeImage =
+ ((pVih->bmiHeader.biWidth + 3) & ~3) *
+ pVih->bmiHeader.biHeight * (pVih->bmiHeader.biBitCount>>3);
+
+ // no cropping, use full video input buffer
+ memset(&(pVih->rcSource), 0, sizeof(RECT));
+ memset(&(pVih->rcTarget), 0, sizeof(RECT));
+
+ // select this format as default
+ if( SUCCEEDED( pSC->SetFormat(p_mt) ) )
+ {
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin video format configured");
+ // no need to check any more media types
+ i = piCount;
+ }
+ else FreeMediaType( *p_mt );
+ }
+ else if( p_mt->majortype == MEDIATYPE_Audio
+ && p_mt->formattype == FORMAT_WaveFormatEx )
+ {
+ AUDIO_STREAM_CONFIG_CAPS *pASCC = reinterpret_cast<AUDIO_STREAM_CONFIG_CAPS*>(pSCC);
+ WAVEFORMATEX *pWfx = reinterpret_cast<WAVEFORMATEX*>(p_mt->pbFormat);
+
+ if( i_channels )
+ {
+ if( i_channels % pASCC->ChannelsGranularity
+ || (unsigned int)i_channels < pASCC->MinimumChannels
+ || (unsigned int)i_channels > pASCC->MaximumChannels )
+ {
+ // required channels not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pWfx->nChannels = i_channels;
+ }
+
+ if( i_samplespersec )
+ {
+ if( i_samplespersec % pASCC->BitsPerSampleGranularity
+ || (unsigned int)i_samplespersec < pASCC->MinimumSampleFrequency
+ || (unsigned int)i_samplespersec > pASCC->MaximumSampleFrequency )
+ {
+ // required sampling rate not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pWfx->nSamplesPerSec = i_samplespersec;
+ }
+
+ if( i_bitspersample )
+ {
+ if( i_bitspersample % pASCC->BitsPerSampleGranularity
+ || (unsigned int)i_bitspersample < pASCC->MinimumBitsPerSample
+ || (unsigned int)i_bitspersample > pASCC->MaximumBitsPerSample )
+ {
+ // required sample size not compatible, try next media type
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ continue;
+ }
+ pWfx->wBitsPerSample = i_bitspersample;
+ }
+
+ // select this format as default
+ if( SUCCEEDED( pSC->SetFormat(p_mt) ) )
+ {
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin default format configured");
+ // no need to check any more media types
+ i = piCount;
+ }
+ }
+ FreeMediaType( *p_mt );
+ CoTaskMemFree( (PVOID)p_mt );
+ }
+ }
+ CoTaskMemFree( (LPVOID)pSCC );
+ }
+ }
+ pSC->Release();
+ }
+
+ /*
+ ** Probe pin for available medias (may be a previously configured one)
+ */
+
+ if( FAILED( p_output_pin->EnumMediaTypes( &p_enummt ) ) )
{
p_output_pin->Release();
continue;
}
- AM_MEDIA_TYPE *p_mt;
+
while( p_enummt->Next( 1, &p_mt, NULL ) == S_OK )
{
- int i_current_fourcc = GetFourCCFromMediaType(*p_mt);
- if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Video )
+ int i_current_fourcc = GetFourCCFromMediaType( *p_mt );
+ if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Video
+ && p_mt->formattype == FORMAT_VideoInfo )
{
- 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;
+ int i_current_width = ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biWidth;
+ int i_current_height = ((VIDEOINFOHEADER *)p_mt->pbFormat)->bmiHeader.biHeight;
+ LONGLONG i_current_atpf = ((VIDEOINFOHEADER *)p_mt->pbFormat)->AvgTimePerFrame;
+
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",
+ "accepts chroma: %4.4s, width:%i, height:%i, fps:%f",
(char *)&i_current_fourcc, i_current_width,
- i_current_height );
+ i_current_height, (10000000.0f/((float)i_current_atpf)) );
if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
( !i_width || i_width == i_current_width ) &&
( !i_height || i_height == i_current_height ) &&
+ ( !i_AvgTimePerFrame || i_AvgTimePerFrame == i_current_atpf ) &&
mt_count < mt_max )
{
/* Pick match */
}
else FreeMediaType( *p_mt );
}
- else if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Audio )
+ else if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Audio
+ && p_mt->formattype == FORMAT_WaveFormatEx)
{
int i_current_channels =
((WAVEFORMATEX *)p_mt->pbFormat)->nChannels;
}
else if( i_current_fourcc && p_mt->majortype == MEDIATYPE_Stream )
{
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin "
+ "accepts stream format: %4.4s",
+ (char *)&i_current_fourcc );
+
if( ( !i_fourcc || i_fourcc == i_current_fourcc ) &&
mt_count < mt_max )
{
}
else
{
- msg_Dbg( p_this, "EnumDeviceCaps: input pin: unknown format" );
+ char *psz_type = "unknown";
+ if( p_mt->majortype == MEDIATYPE_Video ) psz_type = "video";
+ if( p_mt->majortype == MEDIATYPE_Audio ) psz_type = "audio";
+ if( p_mt->majortype == MEDIATYPE_Stream ) psz_type = "stream";
+ msg_Dbg( p_this, "EnumDeviceCaps: input pin media: unknown format "
+ "(%s %4.4s)", psz_type, (char *)&p_mt->subtype );
FreeMediaType( *p_mt );
}
CoTaskMemFree( (PVOID)p_mt );
* Returns -1 in case of error, 0 in case of EOF, otherwise the number of
* bytes.
*****************************************************************************/
-static int ReadCompressed( access_t *p_access, uint8_t *p_buffer, int i_len )
+static block_t *ReadCompressed( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
dshow_stream_t *p_stream = NULL;
- VLCMediaSample sample;
- int i_data_size;
- uint8_t *p_data;
+ VLCMediaSample sample;
/* Read 1 DV/MPEG frame (they contain the video and audio data) */
/*
* We got our sample
*/
- i_data_size = sample.p_sample->GetActualDataLength();
- sample.p_sample->GetPointer( &p_data );
+ block_t *p_block;
+ uint8_t *p_data;
+ int i_data_size = sample.p_sample->GetActualDataLength();
-#if 0
- 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_access->p_vlc->pf_memcpy( p_buffer, p_data, i_data_size );
+ if( !i_data_size || !(p_block = block_New( p_access, i_data_size )) )
+ {
+ sample.p_sample->Release();
+ continue;
+ }
+ sample.p_sample->GetPointer( &p_data );
+ p_access->p_vlc->pf_memcpy( p_block->p_buffer, p_data, i_data_size );
sample.p_sample->Release();
/* The caller got what he wanted */
- return i_data_size;
+ return p_block;
}
return 0; /* never reached */
}
/* Try to grab a video sample */
if( i_stream == p_sys->i_streams )
- for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
{
- p_stream = p_sys->pp_streams[i_stream];
- if( p_stream->p_capture_filter &&
- p_stream->p_capture_filter->CustomGetPin()
- ->CustomGetSample( &sample ) == S_OK )
+ for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
{
- break;
+ p_stream = p_sys->pp_streams[i_stream];
+ if( p_stream->p_capture_filter &&
+ p_stream->p_capture_filter->CustomGetPin()
+ ->CustomGetSample( &sample ) == S_OK )
+ {
+ break;
+ }
}
}
FindCaptureDevice( p_this, &devicename, NULL, b_audio );
if( p_device_filter )
{
- PropertiesPage( p_this, p_device_filter, NULL, b_audio );
+ ShowPropertyPage( p_device_filter );
}
else
{
return VLC_SUCCESS;
}
-static void ShowPropertyPage( IUnknown *obj, CAUUID *cauuid )
+/*****************************************************************************
+ * Properties
+ *****************************************************************************/
+static void ShowPropertyPage( IUnknown *obj )
{
- if( cauuid->cElems > 0 )
+ ISpecifyPropertyPages *p_spec;
+ CAUUID cauuid;
+
+ HRESULT hr = obj->QueryInterface( IID_ISpecifyPropertyPages,
+ (void **)&p_spec );
+ if( FAILED(hr) ) return;
+
+ if( SUCCEEDED(p_spec->GetPages( &cauuid )) )
{
- HWND hwnd_desktop = ::GetDesktopWindow();
+ if( cauuid.cElems > 0 )
+ {
+ HWND hwnd_desktop = ::GetDesktopWindow();
- OleCreatePropertyFrame( hwnd_desktop, 30, 30, NULL, 1, &obj,
- cauuid->cElems, cauuid->pElems, 0, 0, NULL );
+ OleCreatePropertyFrame( hwnd_desktop, 30, 30, NULL, 1, &obj,
+ cauuid.cElems, cauuid.pElems, 0, 0, NULL );
- CoTaskMemFree( cauuid->pElems );
+ CoTaskMemFree( cauuid.pElems );
+ }
+ p_spec->Release();
}
}
-static void PropertiesPage( vlc_object_t *p_this, IBaseFilter *p_device_filter,
- ICaptureGraphBuilder2 *p_capture_graph,
- vlc_bool_t b_audio )
+static void ShowDeviceProperties( vlc_object_t *p_this,
+ ICaptureGraphBuilder2 *p_graph,
+ IBaseFilter *p_device_filter,
+ vlc_bool_t b_audio )
{
- CAUUID cauuid;
-
+ HRESULT hr;
msg_Dbg( p_this, "Configuring Device Properties" );
/*
* Video or audio capture filter page
*/
- ISpecifyPropertyPages *p_spec;
-
- HRESULT hr = p_device_filter->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- if( SUCCEEDED(p_spec->GetPages( &cauuid )) )
- {
- ShowPropertyPage( p_device_filter, &cauuid );
- }
- p_spec->Release();
- }
-
- msg_Dbg( p_this, "looking for WDM Configuration Pages" );
-
- if( p_capture_graph )
- msg_Dbg( p_this, "got capture graph for WDM Configuration Pages" );
+ ShowPropertyPage( p_device_filter );
/*
* Audio capture pin
*/
- if( p_capture_graph && b_audio )
+ if( p_graph && b_audio )
{
IAMStreamConfig *p_SC;
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Audio, p_device_filter,
- IID_IAMStreamConfig,
- (void **)&p_SC );
+ msg_Dbg( p_this, "Showing WDM Audio Configuration Pages" );
+
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Audio, p_device_filter,
+ IID_IAMStreamConfig, (void **)&p_SC );
if( SUCCEEDED(hr) )
{
- hr = p_SC->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- hr = p_spec->GetPages( &cauuid );
- if( SUCCEEDED(hr) )
- {
- for( unsigned int c = 0; c < cauuid.cElems; c++ )
- {
- ShowPropertyPage( p_SC, &cauuid );
- }
- CoTaskMemFree( cauuid.pElems );
- }
- p_spec->Release();
- }
+ ShowPropertyPage(p_SC);
p_SC->Release();
}
* TV Audio filter
*/
IAMTVAudio *p_TVA;
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ HRESULT hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
&MEDIATYPE_Audio, p_device_filter,
IID_IAMTVAudio, (void **)&p_TVA );
if( SUCCEEDED(hr) )
{
- hr = p_TVA->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- if( SUCCEEDED( p_spec->GetPages( &cauuid ) ) )
- ShowPropertyPage(p_TVA, &cauuid);
-
- p_spec->Release();
- }
+ ShowPropertyPage(p_TVA);
p_TVA->Release();
}
}
/*
* Video capture pin
*/
- if( p_capture_graph && !b_audio )
+ if( p_graph && !b_audio )
{
IAMStreamConfig *p_SC;
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Interleaved,
- p_device_filter,
- IID_IAMStreamConfig,
- (void **)&p_SC );
+ msg_Dbg( p_this, "Showing WDM Video Configuration Pages" );
+
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Interleaved, p_device_filter,
+ IID_IAMStreamConfig, (void **)&p_SC );
+ if( FAILED(hr) )
+ {
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Video, p_device_filter,
+ IID_IAMStreamConfig, (void **)&p_SC );
+ }
+
if( FAILED(hr) )
{
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Video,
- p_device_filter,
- IID_IAMStreamConfig,
- (void **)&p_SC );
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Stream, p_device_filter,
+ IID_IAMStreamConfig, (void **)&p_SC );
}
if( SUCCEEDED(hr) )
{
- hr = p_SC->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- if( SUCCEEDED( p_spec->GetPages(&cauuid) ) )
- {
- ShowPropertyPage(p_SC, &cauuid);
- }
- p_spec->Release();
- }
+ ShowPropertyPage(p_SC);
p_SC->Release();
}
+ }
+}
- /*
- * Video crossbar, and a possible second crossbar
- */
- IAMCrossbar *p_X, *p_X2;
- IBaseFilter *p_XF;
+static void ShowTunerProperties( vlc_object_t *p_this,
+ ICaptureGraphBuilder2 *p_graph,
+ IBaseFilter *p_device_filter,
+ vlc_bool_t b_audio )
+{
+ HRESULT hr;
+ msg_Dbg( p_this, "Configuring Tuner Properties" );
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Interleaved,
- p_device_filter,
- IID_IAMCrossbar, (void **)&p_X );
- if( FAILED(hr) )
- {
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Video,
- p_device_filter,
- IID_IAMCrossbar,
- (void **)&p_X );
- }
+ if( !p_graph || b_audio ) return;
- if( SUCCEEDED(hr) )
- {
- hr = p_X->QueryInterface( IID_IBaseFilter, (void **)&p_XF );
- if( SUCCEEDED(hr) )
- {
- hr = p_X->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- hr = p_spec->GetPages(&cauuid);
- if( hr == S_OK && cauuid.cElems > 0 )
- {
- ShowPropertyPage( p_X, &cauuid );
- }
- p_spec->Release();
- }
+ IAMTVTuner *p_TV;
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Interleaved, p_device_filter,
+ IID_IAMTVTuner, (void **)&p_TV );
+ if( FAILED(hr) )
+ {
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Video, p_device_filter,
+ IID_IAMTVTuner, (void **)&p_TV );
+ }
- hr = p_capture_graph->FindInterface( &LOOK_UPSTREAM_ONLY, NULL,
- p_XF, IID_IAMCrossbar,
- (void **)&p_X2 );
- if( SUCCEEDED(hr) )
- {
- hr = p_X2->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- hr = p_spec->GetPages( &cauuid );
- if( SUCCEEDED(hr) )
- {
- ShowPropertyPage( p_X2, &cauuid );
- }
- p_spec->Release();
- }
- p_X2->Release();
- }
+ if( FAILED(hr) )
+ {
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
+ &MEDIATYPE_Stream, p_device_filter,
+ IID_IAMTVTuner, (void **)&p_TV );
+ }
- p_XF->Release();
- }
+ if( SUCCEEDED(hr) )
+ {
+ ShowPropertyPage(p_TV);
+ p_TV->Release();
+ }
+}
- p_X->Release();
- }
+static void ConfigTuner( vlc_object_t *p_this, ICaptureGraphBuilder2 *p_graph,
+ IBaseFilter *p_device_filter )
+{
+ int i_channel, i_country, i_input;
+ long l_modes = 0;
+ IAMTVTuner *p_TV;
+ HRESULT hr;
- /*
- * TV Tuner
- */
- IAMTVTuner *p_TV;
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Interleaved,
- p_device_filter,
- IID_IAMTVTuner, (void **)&p_TV );
- if( FAILED(hr) )
- {
- hr = p_capture_graph->FindInterface( &PIN_CATEGORY_CAPTURE,
- &MEDIATYPE_Video,
- p_device_filter,
- IID_IAMTVTuner,
- (void **)&p_TV );
- }
+ if( !p_graph ) return;
- if( SUCCEEDED(hr) )
- {
- hr = p_TV->QueryInterface( IID_ISpecifyPropertyPages,
- (void **)&p_spec );
- if( SUCCEEDED(hr) )
- {
- hr = p_spec->GetPages(&cauuid);
- if( SUCCEEDED(hr) )
- {
- ShowPropertyPage(p_TV, &cauuid);
- }
- p_spec->Release();
- }
- p_TV->Release();
- }
+ i_channel = var_GetInteger( p_this, "dshow-tuner-channel" );
+ i_country = var_GetInteger( p_this, "dshow-tuner-country" );
+ i_input = var_GetInteger( p_this, "dshow-tuner-input" );
+
+ if( !i_channel && !i_country && !i_input ) return; /* Nothing to do */
+
+ msg_Dbg( p_this, "tuner config: channel %i, country %i, input type %i",
+ i_channel, i_country, i_input );
+
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved,
+ p_device_filter, IID_IAMTVTuner,
+ (void **)&p_TV );
+ if( FAILED(hr) )
+ {
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video,
+ p_device_filter, IID_IAMTVTuner,
+ (void **)&p_TV );
+ }
+
+ if( FAILED(hr) )
+ {
+ hr = p_graph->FindInterface( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Stream,
+ p_device_filter, IID_IAMTVTuner,
+ (void **)&p_TV );
+ }
+
+ if( FAILED(hr) )
+ {
+ msg_Dbg( p_this, "couldn't find tuner interface" );
+ return;
+ }
+
+ hr = p_TV->GetAvailableModes( &l_modes );
+ if( SUCCEEDED(hr) && (l_modes & AMTUNER_MODE_TV) )
+ {
+ hr = p_TV->put_Mode( AMTUNER_MODE_TV );
}
+
+ if( i_input == 1 ) p_TV->put_InputType( 0, TunerInputCable );
+ else if( i_input == 2 ) p_TV->put_InputType( 0, TunerInputAntenna );
+
+ p_TV->put_CountryCode( i_country );
+ p_TV->put_Channel( i_channel, AMTUNER_SUBCHAN_NO_TUNE,
+ AMTUNER_SUBCHAN_NO_TUNE );
+ p_TV->Release();
}
projects / vlc / blobdiff