static PlayerRegistration()
{
EXTENSIONS2PLAYER.Add(".avi", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mpg", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mpeg", typeof(VideoPlayer));
// TsVideoPlayer depends on the MP1 TsReader.ax component, that may not be present. In this case we'll use the default VideoPlayer.
EXTENSIONS2PLAYER.Add(".ts",
FilterGraphTools.IsThisComObjectInstalled(new Guid(TsVideoPlayer.TSREADER_CLSID))
? typeof(TsVideoPlayer)
: typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mts", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".m2ts", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".dvr-ms", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".wtv", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mp4", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mkv", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".mov", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".flv", typeof(VideoPlayer));
EXTENSIONS2PLAYER.Add(".vob", typeof(DvdPlayer));
EXTENSIONS2PLAYER.Add(".ifo", typeof(DvdPlayer));
// TODO: Go on with extensions mapping
// mimetypes are mapped in plugin.xml
}
public static IBaseFilter AddGVQuickTimeFilter(IGraphBuilder graphBuilder, string name)
{
if (FilterGraphTools.IsThisComObjectInstalled(GVQuickTimeFilterId))
{
return(FilterGraphTools.AddFilterFromClsid(graphBuilder, GVQuickTimeFilterId, name));
}
else
{
throw new ArgumentNullException("The GVQuickTime filter is not currently installed");
}
}
protected override void GetAvailableFilters()
{
// Check whether one or more of the SupportedSourceFilters are installed and if so, add them to the codec list
_codecList.Clear();
foreach (CodecInfo codecInfo in SupportedSourceFilters)
{
if (FilterGraphTools.IsThisComObjectInstalled(new Guid(codecInfo.CLSID)))
{
_codecList.Add(codecInfo);
}
}
}
private void AddNetworkProviderFilter(ITuningSpace tuningSpace)
{
int hr = 0;
Guid genProviderClsId = new Guid("{B2F3A67C-29DA-4C78-8831-091ED509A475}");
Guid networkProviderClsId;
// First test if the Generic Network Provider is available (only on MCE 2005 + Update Rollup 2)
if (FilterGraphTools.IsThisComObjectInstalled(genProviderClsId))
{
this.networkProvider = FilterGraphTools.AddFilterFromClsid(this.graphBuilder, genProviderClsId, "Generic Network Provider");
hr = (this.networkProvider as ITuner).put_TuningSpace(tuningSpace);
return;
}
// Get the network type of the requested Tuning Space
hr = tuningSpace.get__NetworkType(out networkProviderClsId);
// Get the network type of the requested Tuning Space
if (networkProviderClsId == typeof(DVBTNetworkProvider).GUID)
{
this.networkProvider = FilterGraphTools.AddFilterFromClsid(this.graphBuilder, networkProviderClsId, "DVBT Network Provider");
}
else if (networkProviderClsId == typeof(DVBSNetworkProvider).GUID)
{
this.networkProvider = FilterGraphTools.AddFilterFromClsid(this.graphBuilder, networkProviderClsId, "DVBS Network Provider");
}
else if (networkProviderClsId == typeof(ATSCNetworkProvider).GUID)
{
this.networkProvider = FilterGraphTools.AddFilterFromClsid(this.graphBuilder, networkProviderClsId, "ATSC Network Provider");
}
else if (networkProviderClsId == typeof(DVBCNetworkProvider).GUID)
{
this.networkProvider = FilterGraphTools.AddFilterFromClsid(this.graphBuilder, networkProviderClsId, "DVBC Network Provider");
}
else
{
// Tuning Space can also describe Analog TV but this application don't support them
throw new ArgumentException("This application doesn't support this Tuning Space");
}
hr = (this.networkProvider as ITuner).put_TuningSpace(tuningSpace);
}
protected override void PrepareFilterRegistrations()
{
Dictionary <Guid, string> filters = new Dictionary <Guid, string>
{
{ new Guid("{D3DD4C59-D3A7-4B82-9727-7B9203EB67C0}"), "MPIPTvSource.ax" },
{ new Guid("{7F2BBEAF-E11C-4D39-90E8-938FB5A86045}"), "PDMpgMux.ax" }
};
foreach (var filter in filters)
{
try
{
if (!FilterGraphTools.IsThisComObjectInstalled(filter.Key))
{
var filterPath = FileUtils.BuildAssemblyRelativePath(filter.Value);
COMRegistration.Register(filterPath, true);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Failed to register filter {0}", ex, filter.Value);
}
}
}
public BDPlayerBuilder()
{
BDPlayerSettings settings = ServiceRegistration.Get <ISettingsManager>().Load <BDPlayerSettings>();
if (settings.BDSourceFilter == null)
{
// Try to init settings with the first available source filter
CodecInfo sourceFilter = BDSourceFilterConfig.SupportedSourceFilters.FirstOrDefault(codecInfo => FilterGraphTools.IsThisComObjectInstalled(new Guid(codecInfo.CLSID)));
if (sourceFilter != null)
{
settings.BDSourceFilter = sourceFilter;
ServiceRegistration.Get <ISettingsManager>().Save(settings);
}
}
Enabled = settings.BDSourceFilter != null;
if (Enabled)
{
LogInfo("Detected BluRay Source Filter '{0}' on the system.", settings.BDSourceFilter.Name);
}
else
{
LogWarn("No BluRay Source Filter was detected on the system.");
}
}
private void DetectSupportedBdaSourceDevices(ref HashSet <string> previouslyKnownDevices, ref HashSet <string> knownDevices)
{
Log.Log.Debug("Detect BDA source devices");
// MS generic, MCE 2005 roll-up 2 or better
bool isMsGenericNpAvailable = FilterGraphTools.IsThisComObjectInstalled(typeof(NetworkProvider).GUID);
DsDevice[] connectedDevices = DsDevice.GetDevicesOfCat(FilterCategory.BDASourceFiltersCategory);
foreach (DsDevice connectedDevice in connectedDevices)
{
string name = connectedDevice.Name;
string devicePath = connectedDevice.DevicePath;
if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(devicePath))
{
continue;
}
if (previouslyKnownDevices.Contains(devicePath))
{
knownDevices.Add(devicePath);
continue;
}
// North American CableCARD tuners [PBDA].
if (name.StartsWith("HDHomeRun Prime") || name.StartsWith("Ceton InfiniTV"))
{
Log.Log.Info("Detected new PBDA CableCARD tuner device {0} {1}", name, devicePath);
TunerPbdaCableCard cableCardTuner = new TunerPbdaCableCard(connectedDevice);
knownDevices.Add(devicePath);
_deviceEventListener.OnDeviceAdded(cableCardTuner);
continue;
}
IBaseFilter tmpDeviceFilter;
try
{
_graphBuilder.AddSourceFilterForMoniker(connectedDevice.Mon, null, name, out tmpDeviceFilter);
}
catch (Exception ex)
{
Log.Log.Error("Failed to add filter to detect device type for {0}!\r\n{1}", name, ex);
continue;
}
try
{
// Silicondust regular (non-CableCARD) HDHomeRun. Workaround for tuner type
// detection issue. The MS generic provider would always detect DVB-T.
bool isCablePreferred = false;
if (name.StartsWith("Silicondust HDHomeRun Tuner"))
{
isCablePreferred = GetHdHomeRunSourceType(name).Equals("Digital Cable");
}
Log.Log.Info("Detected new digital BDA tuner device {0} {1}", name, devicePath);
// Try the MediaPortal network provider first.
ITVCard deviceToAdd = null;
if (_mpNp != null)
{
Log.Log.Debug(" check type with MP NP");
IDvbNetworkProvider interfaceNetworkProvider = (IDvbNetworkProvider)_mpNp;
string hash = GetHash(devicePath);
interfaceNetworkProvider.ConfigureLogging(GetFileName(devicePath), hash, LogLevelOption.Debug);
if (ConnectFilter(_graphBuilder, _mpNp, tmpDeviceFilter))
{
TuningType tuningTypes;
interfaceNetworkProvider.GetAvailableTuningTypes(out tuningTypes);
Log.Log.Debug(" tuning types = {0}, hash = {1}", tuningTypes, hash);
if ((tuningTypes & TuningType.DvbT) != 0 && !isCablePreferred)
{
deviceToAdd = new TvCardDVBT(connectedDevice);
}
else if ((tuningTypes & TuningType.DvbS) != 0 && !isCablePreferred)
{
deviceToAdd = new TvCardDVBS(connectedDevice);
}
else if ((tuningTypes & TuningType.DvbC) != 0)
{
deviceToAdd = new TvCardDVBC(connectedDevice);
}
else if ((tuningTypes & TuningType.Atsc) != 0)
{
deviceToAdd = new TvCardATSC(connectedDevice);
}
else
{
Log.Log.Debug(" connected to MP NP but type not recognised");
}
}
else
{
Log.Log.Debug(" failed to connect to MP NP");
}
}
// Try the Microsoft network provider next if the MP NP
// failed and the MS generic NP is available.
if (deviceToAdd == null && isMsGenericNpAvailable)
{
// Note: the MS NP must be added/removed to/from the graph for each
// device that is checked. If you don't do this, the networkTypes
// list gets longer and longer and longer.
Log.Log.Debug(" check type with MS NP");
IBaseFilter genericNp = null;
try
{
genericNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, typeof(NetworkProvider).GUID, "Microsoft Network Provider");
}
catch
{
genericNp = null;
}
if (genericNp == null)
{
Log.Log.Error(" failed to add MS NP to graph");
}
else
{
if (ConnectFilter(_graphBuilder, genericNp, tmpDeviceFilter))
{
int networkTypesMax = 5;
int networkTypeCount;
Guid[] networkTypes = new Guid[networkTypesMax];
int hr = (genericNp as ITunerCap).get_SupportedNetworkTypes(networkTypesMax, out networkTypeCount, networkTypes);
Log.Log.Debug(" network type count = {0}", networkTypeCount);
for (int n = 0; n < networkTypeCount; n++)
{
Log.Log.Debug(" network type {0} = {1}", n, networkTypes[n]);
}
for (int n = 0; n < networkTypeCount; n++)
{
if (networkTypes[n] == typeof(DVBTNetworkProvider).GUID && !isCablePreferred)
{
deviceToAdd = new TvCardDVBT(connectedDevice);
}
else if (networkTypes[n] == typeof(DVBSNetworkProvider).GUID && !isCablePreferred)
{
deviceToAdd = new TvCardDVBS(connectedDevice);
}
else if (networkTypes[n] == typeof(DVBCNetworkProvider).GUID)
{
deviceToAdd = new TvCardDVBC(connectedDevice);
}
else if (networkTypes[n] == typeof(ATSCNetworkProvider).GUID)
{
deviceToAdd = new TvCardATSC(connectedDevice);
}
if (deviceToAdd != null)
{
break;
}
else if (n == (networkTypeCount - 1))
{
Log.Log.Debug(" connected to MS NP but type not recognised");
}
}
}
else
{
Log.Log.Debug(" failed to connect to MS NP");
}
_graphBuilder.RemoveFilter(genericNp);
Release.ComObject("device detection generic network provider", genericNp);
genericNp = null;
}
}
// Last shot is the old style Microsoft network providers.
if (deviceToAdd == null)
{
Log.Log.Debug(" check type with specific NPs");
if (ConnectFilter(_graphBuilder, _dvbtNp, tmpDeviceFilter))
{
deviceToAdd = new TvCardDVBT(connectedDevice);
}
else if (ConnectFilter(_graphBuilder, _dvbcNp, tmpDeviceFilter))
{
deviceToAdd = new TvCardDVBC(connectedDevice);
}
else if (ConnectFilter(_graphBuilder, _dvbsNp, tmpDeviceFilter))
{
deviceToAdd = new TvCardDVBS(connectedDevice);
}
else if (ConnectFilter(_graphBuilder, _atscNp, tmpDeviceFilter))
{
deviceToAdd = new TvCardATSC(connectedDevice);
}
else
{
Log.Log.Debug(" failed to connect to specific NP");
}
}
if (deviceToAdd != null)
{
Log.Log.Info(" tuner type = {0}", deviceToAdd.CardType);
knownDevices.Add(devicePath);
_deviceEventListener.OnDeviceAdded(deviceToAdd);
}
}
finally
{
_graphBuilder.RemoveFilter(tmpDeviceFilter);
Release.ComObject("device detection device filter", tmpDeviceFilter);
}
}
}
private void InitBdaDetectionGraph()
{
Log.Log.Debug("Initialise BDA device detection graph");
_graphBuilder = (IFilterGraph2) new FilterGraph();
_rotEntry = new DsROTEntry(_graphBuilder);
Guid mpNetworkProviderClsId = new Guid("{D7D42E5C-EB36-4aad-933B-B4C419429C98}");
if (FilterGraphTools.IsThisComObjectInstalled(mpNetworkProviderClsId))
{
_mpNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, mpNetworkProviderClsId, "MediaPortal Network Provider");
return;
}
ITuningSpace tuningSpace = null;
ILocator locator = null;
// ATSC
_atscNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, typeof(ATSCNetworkProvider).GUID, "ATSC Network Provider");
tuningSpace = (ITuningSpace) new ATSCTuningSpace();
tuningSpace.put_UniqueName("ATSC TuningSpace");
tuningSpace.put_FriendlyName("ATSC TuningSpace");
((IATSCTuningSpace)tuningSpace).put_MaxChannel(10000);
((IATSCTuningSpace)tuningSpace).put_MaxMinorChannel(10000);
((IATSCTuningSpace)tuningSpace).put_MinChannel(0);
((IATSCTuningSpace)tuningSpace).put_MinMinorChannel(0);
((IATSCTuningSpace)tuningSpace).put_MinPhysicalChannel(0);
((IATSCTuningSpace)tuningSpace).put_InputType(TunerInputType.Antenna);
locator = (IATSCLocator) new ATSCLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
locator.put_CarrierFrequency(-1);
((IATSCLocator)locator).put_PhysicalChannel(-1);
((IATSCLocator)locator).put_TSID(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)_atscNp).put_TuningSpace(tuningSpace);
// DVB-C
_dvbcNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, typeof(DVBCNetworkProvider).GUID, "DVB-C Network Provider");
tuningSpace = (ITuningSpace) new DVBTuningSpace();
tuningSpace.put_UniqueName("DVB-C TuningSpace");
tuningSpace.put_FriendlyName("DVB-C TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBCNetworkProvider).GUID);
((IDVBTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Cable);
locator = (ILocator) new DVBCLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)_dvbcNp).put_TuningSpace(tuningSpace);
// DVB-S
_dvbsNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, typeof(DVBSNetworkProvider).GUID, "DVB-S Network Provider");
tuningSpace = (ITuningSpace) new DVBSTuningSpace();
tuningSpace.put_UniqueName("DVB-S TuningSpace");
tuningSpace.put_FriendlyName("DVB-S TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBSNetworkProvider).GUID);
((IDVBSTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Satellite);
locator = (ILocator) new DVBTLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)_dvbsNp).put_TuningSpace(tuningSpace);
// DVB-T
_dvbtNp = FilterGraphTools.AddFilterFromClsid(_graphBuilder, typeof(DVBTNetworkProvider).GUID, "DVB-T Network Provider");
tuningSpace = (ITuningSpace) new DVBTuningSpace();
tuningSpace.put_UniqueName("DVB-T TuningSpace");
tuningSpace.put_FriendlyName("DVB-T TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBTNetworkProvider).GUID);
((IDVBTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Terrestrial);
locator = (ILocator) new DVBTLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)_dvbtNp).put_TuningSpace(tuningSpace);
}
DSStreamResultCodes InitWithStreamBufferFile(WTVStreamingVideoRequest strq)
{
// Init variables
//IPin[] pin = new IPin[1];
IBaseFilter DecFilterAudio = null;
IBaseFilter DecFilterVideo = null;
IBaseFilter MainAudioDecoder = null;
IBaseFilter MainVideoDecoder = null;
string dPin = string.Empty;
string sName = string.Empty;
string dName = string.Empty;
string sPin = string.Empty;
FileInfo fiInputFile = new FileInfo(strq.FileName);
string txtOutputFNPath = fiInputFile.FullName + ".wmv";
if (
(!fiInputFile.Extension.ToLowerInvariant().Equals(".wtv")) &&
(!fiInputFile.Extension.ToLowerInvariant().Equals(".dvr-ms"))
)
{
return(DSStreamResultCodes.ErrorInvalidFileType);
}
int hr = 0;
try
{
// Get the graphbuilder interface
SendDebugMessage("Creating Graph Object", 0);
IGraphBuilder graphbuilder = (IGraphBuilder)currentFilterGraph;
// Add the DVRMS/WTV file / filter to the graph
SendDebugMessage("Add SBE Source Filter", 0);
hr = graphbuilder.AddSourceFilter(fiInputFile.FullName, "SBE Filter", out currentSBEfilter); // class variable
DsError.ThrowExceptionForHR(hr);
dc.Add(currentSBEfilter);
// Get the SBE audio and video out pins
IPin SBEVidOutPin, SBEAudOutPin;
SBEAudOutPin = FilterGraphTools.FindPinByMediaType(currentSBEfilter, PinDirection.Output, MediaType.Audio, MediaSubType.Null);
SBEVidOutPin = FilterGraphTools.FindPinByMediaType(currentSBEfilter, PinDirection.Output, MediaType.Video, MediaSubType.Null);
// Set up two decrypt filters according to file extension (assume audio and video both present )
if (fiInputFile.Extension.ToLowerInvariant().Equals(".dvr-ms"))
{
// Add DVR-MS decrypt filters
SendDebugMessage("Add DVRMS (bda) decryption", 0);
DecFilterAudio = (IBaseFilter) new DTFilter(); // THESE ARE FOR DVR-MS (BDA DTFilters)
DecFilterVideo = (IBaseFilter) new DTFilter();
graphbuilder.AddFilter(DecFilterAudio, "Decrypt / Tag");
graphbuilder.AddFilter(DecFilterVideo, "Decrypt / Tag 0001");
}
else // Add WTV decrypt filters
{
SendDebugMessage("Add WTV (pbda) decryption", 0);
DecFilterAudio = FilterDefinition.AddToFilterGraph(FilterDefinitions.Decrypt.DTFilterPBDA, ref graphbuilder);
DecFilterVideo = FilterDefinition.AddToFilterGraph(FilterDefinitions.Decrypt.DTFilterPBDA, ref graphbuilder, "PBDA DTFilter 0001");
}
dc.Add(DecFilterAudio);
dc.Add(DecFilterVideo);
// Make the first link in the graph: SBE => Decrypts
SendDebugMessage("Connect SBE => Decrypt filters", 0);
IPin DecVideoInPin = DsFindPin.ByDirection(DecFilterVideo, PinDirection.Input, 0);
FilterGraphTools.ConnectFilters(graphbuilder, SBEVidOutPin, DecVideoInPin, false);
IPin DecAudioInPin = DsFindPin.ByDirection(DecFilterAudio, PinDirection.Input, 0);
if (DecAudioInPin == null)
{
SendDebugMessage("WARNING: No Audio Input to decrypt filter.");
}
else
{
FilterGraphTools.ConnectFilters(graphbuilder, SBEAudOutPin, DecAudioInPin, false);
}
// Get Dec Audio Out pin
IPin DecAudioOutPin = DsFindPin.ByDirection(DecFilterAudio, PinDirection.Output, 0);
// Examine Dec Audio out for audio format
SendDebugMessage("Examining source audio", 0);
AMMediaType AudioMediaType = null;
getPinMediaType(DecAudioOutPin, MediaType.Audio, Guid.Empty, Guid.Empty, ref AudioMediaType);
SendDebugMessage("Audio media subtype: " + AudioMediaType.subType.ToString());
SendDebugMessage("Examining Audio StreamInfo");
StreamInfo si = FileInformation.GetStreamInfo(AudioMediaType);
bool AudioIsAC3 = (si.SimpleType == "AC-3");
if (AudioIsAC3)
{
SendDebugMessage("Audio type is AC3");
}
else
{
SendDebugMessage("Audio type is not AC3");
}
si = null;
DsUtils.FreeAMMediaType(AudioMediaType);
// Add an appropriate audio decoder
if (AudioIsAC3)
{
if (!FilterGraphTools.IsThisComObjectInstalled(FilterDefinitions.Audio.AudioDecoderMPCHC.CLSID))
{
SendDebugMessage("Missing AC3 Audio Decoder, and AC3 audio detected.");
return(DSStreamResultCodes.ErrorAC3CodecNotFound);
}
else
{
MainAudioDecoder = FilterDefinition.AddToFilterGraph(FilterDefinitions.Audio.AudioDecoderMPCHC, ref graphbuilder); //MainAudioDecoder = FatAttitude.WTVTranscoder.FilterDefinitions.Audio.AudioDecoderFFDShow.AddToFilterGraph(ref graph);
Guid tmpGuid; MainAudioDecoder.GetClassID(out tmpGuid);
SendDebugMessage("Main Audio decoder CLSID is " + tmpGuid.ToString());
}
}
else
{
MainAudioDecoder = FilterDefinition.AddToFilterGraph(FilterDefinitions.Audio.AudioDecoderMSDTV, ref graphbuilder);
}
// Add a video decoder
SendDebugMessage("Add DTV decoder", 0);
MainVideoDecoder = FilterDefinition.AddToFilterGraph(FilterDefinitions.Video.VideoDecoderMSDTV, ref graphbuilder);
dc.Add(MainAudioDecoder);
dc.Add(MainVideoDecoder);
//SetAudioDecoderOutputToPCMStereo(MainAudioDecoder);
// Add a null renderer
SendDebugMessage("Add null renderer", 0);
NullRenderer MyNullRenderer = new NullRenderer();
dc.Add(MyNullRenderer);
hr = graphbuilder.AddFilter((IBaseFilter)MyNullRenderer, @"Null Renderer");
DsError.ThrowExceptionForHR(hr);
// Link up video through to null renderer
SendDebugMessage("Connect video to null renderer", 0);
// Make the second link: Decrypts => DTV
IPin DecVideoOutPin = DsFindPin.ByDirection(DecFilterVideo, PinDirection.Output, 0);
IPin DTVVideoInPin = DsFindPin.ByName(MainVideoDecoder, @"Video Input"); // IPin DTVVideoInPin = DsFindPin.ByDirection(DTVVideoDecoder, PinDirection.Input, 0); // first one should be video input? //
FilterGraphTools.ConnectFilters(graphbuilder, DecVideoOutPin, DTVVideoInPin, false);
// 3. DTV => Null renderer
IPin NullRInPin = DsFindPin.ByDirection((IBaseFilter)MyNullRenderer, PinDirection.Input, 0);
IPin DTVVideoOutPin = FilterGraphTools.FindPinByMediaType(MainVideoDecoder, PinDirection.Output, MediaType.Video, MediaSubType.Null);
FilterGraphTools.ConnectFilters(graphbuilder, DTVVideoOutPin, NullRInPin, false);
Marshal.ReleaseComObject(NullRInPin); NullRInPin = null;
// Run graph [can use this also to get media type => see, e.g. dvrmstowmvhd by Babgvant]
SendDebugMessage("Run graph for testing purposes", 0);
IMediaControl tempControl = (IMediaControl)graphbuilder;
IMediaEvent tempEvent = (IMediaEvent)graphbuilder;
DsError.ThrowExceptionForHR(tempControl.Pause());
DsError.ThrowExceptionForHR(tempControl.Run());
EventCode pEventCode;
hr = tempEvent.WaitForCompletion(1000, out pEventCode);
//DsError.ThrowExceptionForHR(hr); // DO *NOT* DO THIS HERE! THERE MAY WELL BE AN ERROR DUE TO EVENTS RAISED BY THE STREAM BUFFER ENGINE, THIS IS A DELIBERATE TEST RUN OF THE GRAPH
// Stop graph if necessary
FilterState pFS;
hr = tempControl.GetState(1000, out pFS);
if (pFS == FilterState.Running)
{
DsError.ThrowExceptionForHR(tempControl.Stop());
}
// Remove null renderer
hr = graphbuilder.RemoveFilter((IBaseFilter)MyNullRenderer);
// Now graph has been run and stopped we can get the video width and height from the output pin of the main video decoder
AMMediaType pmt = null;
getPinMediaType(DTVVideoOutPin, MediaType.Video, MediaSubType.YUY2, Guid.Empty, ref pmt);
FrameSize SourceFrameSize;
if (pmt.formatType == FormatType.VideoInfo2)
{
VideoInfoHeader2 pvih2 = new VideoInfoHeader2();
Marshal.PtrToStructure(pmt.formatPtr, pvih2);
int VideoWidth = pvih2.BmiHeader.Width;
int VideoHeight = pvih2.BmiHeader.Height;
SourceFrameSize = new FrameSize(VideoWidth, VideoHeight);
}
else
{
SourceFrameSize = new FrameSize(320, 240);
}
// Free up
DsUtils.FreeAMMediaType(pmt); pmt = null;
// Link up audio
// 2. Audio Decrypt -> Audio decoder
IPin MainAudioInPin = DsFindPin.ByDirection(MainAudioDecoder, PinDirection.Input, 0);
FilterGraphTools.ConnectFilters(graphbuilder, DecAudioOutPin, MainAudioInPin, false);
// Add ASF Writer
// Create an ASF writer filter
SendDebugMessage("Creating ASF Writer", 0);
WMAsfWriter asf_filter = new WMAsfWriter();
dc.Add(asf_filter); // CHECK FOR ERRORS
currentOutputFilter = (IBaseFilter)asf_filter; // class variable
// Add the ASF filter to the graph
hr = graphbuilder.AddFilter((IBaseFilter)asf_filter, "WM Asf Writer");
DsError.ThrowExceptionForHR(hr);
// Set the filename
IFileSinkFilter sinkFilter = (IFileSinkFilter)asf_filter;
string destPathFN = fiInputFile.FullName + ".wmv";
hr = sinkFilter.SetFileName(destPathFN, null);
DsError.ThrowExceptionForHR(hr);
// Make the final links: DTV => writer
SendDebugMessage("Linking audio/video through to decoder and writer", 0);
IPin DTVAudioOutPin = DsFindPin.ByDirection(MainAudioDecoder, PinDirection.Output, 0);
IPin ASFAudioInputPin = FilterGraphTools.FindPinByMediaType((IBaseFilter)asf_filter, PinDirection.Input, MediaType.Audio, MediaSubType.Null);
IPin ASFVideoInputPin = FilterGraphTools.FindPinByMediaType((IBaseFilter)asf_filter, PinDirection.Input, MediaType.Video, MediaSubType.Null);
FilterGraphTools.ConnectFilters(graphbuilder, DTVAudioOutPin, ASFAudioInputPin, false);
if (ASFVideoInputPin != null)
{
FilterGraphTools.ConnectFilters(graphbuilder, DTVVideoOutPin, ASFVideoInputPin, false);
}
// Configure ASFWriter
ConfigureASFWriter(asf_filter, strq, SourceFrameSize);
// Release pins
SendDebugMessage("Releasing COM objects (pins)", 0);
// dec
Marshal.ReleaseComObject(DecAudioInPin); DecAudioInPin = null;
Marshal.ReleaseComObject(DecVideoInPin); DecVideoInPin = null;
Marshal.ReleaseComObject(DecVideoOutPin); DecVideoOutPin = null;
Marshal.ReleaseComObject(DecAudioOutPin); DecAudioOutPin = null;
// dtv
Marshal.ReleaseComObject(MainAudioInPin); MainAudioInPin = null;
Marshal.ReleaseComObject(DTVVideoInPin); DTVVideoInPin = null;
Marshal.ReleaseComObject(DTVVideoOutPin); DTVVideoOutPin = null;
Marshal.ReleaseComObject(DTVAudioOutPin); DTVAudioOutPin = null;
// asf
Marshal.ReleaseComObject(ASFAudioInputPin); ASFAudioInputPin = null;
Marshal.ReleaseComObject(ASFVideoInputPin); ASFVideoInputPin = null;
}
catch (Exception ex)
{
SendDebugMessageWithException(ex.Message, ex);
return(DSStreamResultCodes.ErrorExceptionOccurred);
}
return(DSStreamResultCodes.OK);
}
private void FormEditCard_Load(object sender, EventArgs e)
{
if (_cardType.Equals("Analog")) //analog does not have these settings
{
checkBoxCAMenabled.Enabled = false;
numericUpDownDecryptLimit.Value = 0;
numericUpDownDecryptLimit.Enabled = false;
checkBoxAllowEpgGrab.Checked = false;
checkBoxAllowEpgGrab.Enabled = false;
}
else
{
ComboBoxCamType.SelectedIndex = _card.CamType;
numericUpDownDecryptLimit.Value = _card.DecryptLimit;
numericUpDownDecryptLimit.Enabled = true;
checkBoxAllowEpgGrab.Checked = _card.GrabEPG;
checkBoxAllowEpgGrab.Enabled = true;
}
IList <CardGroupMap> GrpList = _card.ReferringCardGroupMap();
if (GrpList.Count != 0)
{
checkBoxPreloadCard.Enabled = false;
_card.PreloadCard = false;
}
checkBoxPreloadCard.Checked = _card.PreloadCard;
checkBoxCAMenabled.Checked = _card.CAM;
radioStopCard.Checked = _card.StopGraph;
radioPauseCard.Checked = !radioStopCard.Checked;
setCAMLimitVisibility();
Text += " " + _card.Name;
// Add Network provider based on card type into combobox
if (_cardType == "DvbT")
{
comboBoxNetProvider.Items.Add((TvDatabase.DbNetworkProvider.DVBT));
}
if (_cardType == "DvbS")
{
comboBoxNetProvider.Items.Add((TvDatabase.DbNetworkProvider.DVBS));
}
if (_cardType == "DvbC")
{
comboBoxNetProvider.Items.Add((TvDatabase.DbNetworkProvider.DVBC));
}
if (_cardType == "Atsc")
{
comboBoxNetProvider.Items.Add((TvDatabase.DbNetworkProvider.ATSC));
}
// Guid for generic network provider
Guid genProviderClsId = new Guid("{B2F3A67C-29DA-4C78-8831-091ED509A475}");
// First test if the Generic Network Provider is available (only on Xp MCE 2005 + Update Rollup 2 & Vista Home Premium and Ultimate & Windows 7 Home Premium, Ultimate, Professional, and Enterprise)
if (FilterGraphTools.IsThisComObjectInstalled(genProviderClsId))
{
// Generic Network provider is available, so add it to selection box.
comboBoxNetProvider.Items.Add((TvDatabase.DbNetworkProvider.Generic));
}
comboBoxNetProvider.SelectedItem = (TvDatabase.DbNetworkProvider)_card.netProvider;
}
/// <summary>
/// Enumerate all tvcard devices and add them to the list
/// </summary>
private void DetectCards()
{
ITunerCap _providerType;
bool genericNP = false;
//SkyStar 2 & IP Streaming
DsDevice[] devices = DsDevice.GetDevicesOfCat(FilterCategory.LegacyAmFilterCategory);
for (int i = 0; i < devices.Length; ++i)
{
if (String.Compare(devices[i].Name, "B2C2 MPEG-2 Source", true) == 0)
{
Log.Log.WriteFile("Detected SkyStar 2 card");
TvCardDvbSS2 card = new TvCardDvbSS2(_epgEvents, devices[i]);
_cards.Add(card);
//break; maybe more than one B2C2 card ?
}
else if (String.Compare(devices[i].Name, "Elecard NWSource-Plus", true) == 0)
{
TvBusinessLayer layer = new TvBusinessLayer();
Setting setting;
setting = layer.GetSetting("iptvCardCount", "1");
int iptvCardCount = Convert.ToInt32(setting.Value);
for (int cardNum = 0; cardNum < iptvCardCount; cardNum++)
{
Log.Log.WriteFile("Detected IP TV Card " + cardNum);
TvCardDVBIP card = new TvCardDVBIPElecard(_epgEvents, devices[i], cardNum);
_cards.Add(card);
}
}
else if (String.Compare(devices[i].Name, "MediaPortal IPTV Source Filter", true) == 0)
{
TvBusinessLayer layer = new TvBusinessLayer();
Setting setting;
setting = layer.GetSetting("iptvCardCount", "1");
int iptvCardCount = Convert.ToInt32(setting.Value);
for (int cardNum = 0; cardNum < iptvCardCount; cardNum++)
{
Log.Log.WriteFile("Detected IP TV Card " + cardNum);
TvCardDVBIP card = new TvCardDVBIPBuiltIn(_epgEvents, devices[i], cardNum);
_cards.Add(card);
}
}
}
//Hauppauge HD PVR & Colossus
devices = DsDevice.GetDevicesOfCat(FilterCategory.AMKSCrossbar);
for (int i = 0; i < devices.Length; ++i)
{
if (devices[i].Name == null)
{
continue;
}
if (devices[i].Name.Equals("Hauppauge HD PVR Crossbar"))
{
Log.Log.WriteFile("Detected Hauppauge HD PVR");
TvCardHDPVR card = new TvCardHDPVR(devices[i]);
_cards.Add(card);
}
else if (devices[i].Name.Contains("Hauppauge Colossus Crossbar"))
{
Log.Log.WriteFile("Detected Hauppauge Colossus");
TvCardHDPVR card = new TvCardHDPVR(devices[i]);
_cards.Add(card);
}
}
//BDA TV devices
devices = DsDevice.GetDevicesOfCat(FilterCategory.BDASourceFiltersCategory);
if (devices.Length > 0)
{
IFilterGraph2 graphBuilder = (IFilterGraph2) new FilterGraph();
DsROTEntry rotEntry = new DsROTEntry(graphBuilder);
Guid networkProviderClsId = new Guid("{D7D42E5C-EB36-4aad-933B-B4C419429C98}");
if (FilterGraphTools.IsThisComObjectInstalled(networkProviderClsId))
{
handleInternalNetworkProviderFilter(devices, graphBuilder, networkProviderClsId, rotEntry);
}
else
{
ITuningSpace tuningSpace = null;
ILocator locator = null;
//DVBT
IBaseFilter networkDVBT = null;
try
{
networkProviderClsId = typeof(DVBTNetworkProvider).GUID;
networkDVBT = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"DVBT Network Provider");
tuningSpace = (ITuningSpace) new DVBTuningSpace();
tuningSpace.put_UniqueName("DVBT TuningSpace");
tuningSpace.put_FriendlyName("DVBT TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBTNetworkProvider).GUID);
((IDVBTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Terrestrial);
locator = (ILocator) new DVBTLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)networkDVBT).put_TuningSpace(tuningSpace);
}
catch (Exception ex)
{
Log.Log.Error("DVBT card detection error: {0}", ex.ToString());
}
//DVBS
networkProviderClsId = typeof(DVBSNetworkProvider).GUID;
IBaseFilter networkDVBS = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"DVBS Network Provider");
tuningSpace = (ITuningSpace) new DVBSTuningSpace();
tuningSpace.put_UniqueName("DVBS TuningSpace");
tuningSpace.put_FriendlyName("DVBS TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBSNetworkProvider).GUID);
((IDVBSTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Satellite);
locator = (ILocator) new DVBTLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)networkDVBS).put_TuningSpace(tuningSpace);
//ATSC
networkProviderClsId = typeof(ATSCNetworkProvider).GUID;
IBaseFilter networkATSC = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"ATSC Network Provider");
tuningSpace = (ITuningSpace) new ATSCTuningSpace();
tuningSpace.put_UniqueName("ATSC TuningSpace");
tuningSpace.put_FriendlyName("ATSC TuningSpace");
((IATSCTuningSpace)tuningSpace).put_MaxChannel(10000);
((IATSCTuningSpace)tuningSpace).put_MaxMinorChannel(10000);
((IATSCTuningSpace)tuningSpace).put_MinChannel(0);
((IATSCTuningSpace)tuningSpace).put_MinMinorChannel(0);
((IATSCTuningSpace)tuningSpace).put_MinPhysicalChannel(0);
((IATSCTuningSpace)tuningSpace).put_InputType(TunerInputType.Antenna);
locator = (IATSCLocator) new ATSCLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
locator.put_CarrierFrequency(-1);
((IATSCLocator)locator).put_PhysicalChannel(-1);
((IATSCLocator)locator).put_TSID(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)networkATSC).put_TuningSpace(tuningSpace);
//DVBC
networkProviderClsId = typeof(DVBCNetworkProvider).GUID;
IBaseFilter networkDVBC = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"DVBC Network Provider");
tuningSpace = (ITuningSpace) new DVBTuningSpace();
tuningSpace.put_UniqueName("DVBC TuningSpace");
tuningSpace.put_FriendlyName("DVBC TuningSpace");
tuningSpace.put__NetworkType(typeof(DVBCNetworkProvider).GUID);
((IDVBTuningSpace)tuningSpace).put_SystemType(DVBSystemType.Cable);
locator = (ILocator) new DVBCLocator();
locator.put_CarrierFrequency(-1);
locator.put_InnerFEC(FECMethod.MethodNotSet);
locator.put_InnerFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_Modulation(ModulationType.ModNotSet);
locator.put_OuterFEC(FECMethod.MethodNotSet);
locator.put_OuterFECRate(BinaryConvolutionCodeRate.RateNotSet);
locator.put_SymbolRate(-1);
tuningSpace.put_DefaultLocator(locator);
((ITuner)networkDVBC).put_TuningSpace(tuningSpace);
//MS Network Provider - MCE Roll-up 2 or better
networkProviderClsId = typeof(NetworkProvider).GUID;
// First test if the Generic Network Provider is available (only on MCE 2005 + Update Rollup 2)
if (FilterGraphTools.IsThisComObjectInstalled(networkProviderClsId))
{
genericNP = true;
}
for (int i = 0; i < devices.Length; i++)
{
bool connected = false;
bool isCablePreferred = false;
string name = devices[i].Name ?? "unknown";
name = name.ToLowerInvariant();
Log.Log.WriteFile("Found card:{0}", name);
//silicondust work-around for dvb type detection issue. generic provider would always use dvb-t
if (name.Contains("silicondust hdhomerun tuner"))
{
isCablePreferred = CheckHDHomerunCablePrefered(name);
Log.Log.WriteFile("silicondust hdhomerun detected - prefer cable mode: {0}", isCablePreferred);
}
IBaseFilter tmp;
try
{
graphBuilder.AddSourceFilterForMoniker(devices[i].Mon, null, name, out tmp);
}
catch (InvalidComObjectException)
{
//ignore bad card
Log.Log.WriteFile("cannot add filter {0} to graph", devices[i].Name);
continue;
}
//Use the Microsoft Network Provider method first but only if available
if (genericNP)
{
IBaseFilter networkDVB = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"Microsoft Network Provider");
if (ConnectFilter(graphBuilder, networkDVB, tmp))
{
Log.Log.WriteFile("Detected DVB card:{0}", name);
// determine the DVB card supported GUIDs here!
_providerType = networkDVB as ITunerCap;
int ulcNetworkTypesMax = 5;
int pulcNetworkTypes;
Guid[] pguidNetworkTypes = new Guid[ulcNetworkTypesMax];
int hr = _providerType.get_SupportedNetworkTypes(ulcNetworkTypesMax, out pulcNetworkTypes,
pguidNetworkTypes);
for (int n = 0; n < pulcNetworkTypes; n++)
{
Log.Log.Debug("Detecting type by MSNP {0}: {1}", n, pguidNetworkTypes[n]);
//test the first found guid to determine the DVB card type
if (pguidNetworkTypes[n] == (typeof(DVBTNetworkProvider).GUID) && !isCablePreferred)
{
Log.Log.WriteFile("Detected DVB-T* card:{0}", name);
TvCardDVBT dvbtCard = new TvCardDVBT(_epgEvents, devices[i]);
_cards.Add(dvbtCard);
connected = true;
}
else if (pguidNetworkTypes[n] == (typeof(DVBSNetworkProvider).GUID) && !isCablePreferred)
{
Log.Log.WriteFile("Detected DVB-S* card:{0}", name);
TvCardDVBS dvbsCard = new TvCardDVBS(_epgEvents, devices[i]);
_cards.Add(dvbsCard);
connected = true;
}
else if (pguidNetworkTypes[n] == (typeof(DVBCNetworkProvider).GUID))
{
Log.Log.WriteFile("Detected DVB-C* card:{0}", name);
TvCardDVBC dvbcCard = new TvCardDVBC(_epgEvents, devices[i]);
_cards.Add(dvbcCard);
connected = true;
}
else if (pguidNetworkTypes[n] == (typeof(ATSCNetworkProvider).GUID))
{
Log.Log.WriteFile("Detected ATSC* card:{0}", name);
TvCardATSC dvbsCard = new TvCardATSC(_epgEvents, devices[i]);
_cards.Add(dvbsCard);
connected = true;
}
if (connected)
{
graphBuilder.RemoveFilter(tmp);
Release.ComObject("tmp filter", tmp);
break; // already found one, no need to continue
}
else if (n == (pulcNetworkTypes - 1))
{
Log.Log.WriteFile("Connected with generic MS Network Provider however network types don't match, using the original method");
}
}
}
else
{
Log.Log.WriteFile("Not connected with generic MS Network Provider, using the original method");
connected = false;
}
graphBuilder.RemoveFilter(networkDVB);
Release.ComObject("ms provider", networkDVB);
}
if (!genericNP || !connected)
{
if (ConnectFilter(graphBuilder, networkDVBT, tmp))
{
Log.Log.WriteFile("Detected DVB-T card:{0}", name);
TvCardDVBT dvbtCard = new TvCardDVBT(_epgEvents, devices[i]);
_cards.Add(dvbtCard);
}
else if (ConnectFilter(graphBuilder, networkDVBC, tmp))
{
Log.Log.WriteFile("Detected DVB-C card:{0}", name);
TvCardDVBC dvbcCard = new TvCardDVBC(_epgEvents, devices[i]);
_cards.Add(dvbcCard);
}
else if (ConnectFilter(graphBuilder, networkDVBS, tmp))
{
Log.Log.WriteFile("Detected DVB-S card:{0}", name);
TvCardDVBS dvbsCard = new TvCardDVBS(_epgEvents, devices[i]);
_cards.Add(dvbsCard);
}
else if (ConnectFilter(graphBuilder, networkATSC, tmp))
{
Log.Log.WriteFile("Detected ATSC card:{0}", name);
TvCardATSC dvbsCard = new TvCardATSC(_epgEvents, devices[i]);
_cards.Add(dvbsCard);
}
graphBuilder.RemoveFilter(tmp);
Release.ComObject("tmp filter", tmp);
}
}
FilterGraphTools.RemoveAllFilters(graphBuilder);
Release.ComObject("dvbc provider", networkDVBC);
Release.ComObject("atsc provider", networkATSC);
Release.ComObject("dvbs provider", networkDVBS);
Release.ComObject("dvbt provider", networkDVBT);
rotEntry.Dispose();
Release.ComObject("graph builder", graphBuilder);
}
}
//Analogue TV devices
devices = DsDevice.GetDevicesOfCat(FilterCategory.AMKSTVTuner);
for (int i = 0; i < devices.Length; i++)
{
string name = devices[i].Name ?? "unknown";
name = name.ToLowerInvariant();
Log.Log.WriteFile("Detected analog card:{0}", name);
TvCardAnalog analogCard = new TvCardAnalog(devices[i]);
_cards.Add(analogCard);
}
_cards.Add(new RadioWebStreamCard());
}
