protected override void Decompose()
{
if (this.graphBuilder != null)
{
int hr = 0;
OnGraphEnded();
// Decompose the graph
if (GetGraphState() != FilterState.Stopped)
{
try { hr = (this.graphBuilder as IMediaControl).StopWhenReady(); }
catch { }
try { hr = (this.graphBuilder as IMediaControl).Stop(); }
catch { }
}
RemoveHandlers();
FilterGraphTools.RemoveAllFilters(this.graphBuilder);
if (this.filterSource != null)
{
Marshal.ReleaseComObject(this.filterSource);
}
this.filterSource = null;
if (this.mpeg2Demux != null)
{
Marshal.ReleaseComObject(this.mpeg2Demux);
}
this.mpeg2Demux = null;
if (this.audioRenderer != null)
{
Marshal.ReleaseComObject(this.audioRenderer);
}
this.audioRenderer = null;
if (this.videoRenderer != null)
{
Marshal.ReleaseComObject(this.videoRenderer);
}
this.videoRenderer = null;
try { rot.Dispose(); }
catch { }
try { Marshal.ReleaseComObject(this.graphBuilder); this.graphBuilder = null; }
catch { }
}
}
protected override void FreeCodecs()
{
// Free all filters from graph
if (_graphBuilder != null)
{
FilterGraphTools.RemoveAllFilters(_graphBuilder, true);
}
FilterGraphTools.TryDispose(ref _rot);
FilterGraphTools.TryRelease(ref _graphBuilder);
// Free file source
FilterGraphTools.TryRelease(ref _fileSource);
}
/// <summary>
/// Frees the audio/video codecs.
/// </summary>
protected override void FreeCodecs()
{
// Release stream selectors
ReleaseStreamSelectors();
// Free all filters from graph
if (_graphBuilder != null)
{
FilterGraphTools.RemoveAllFilters(_graphBuilder, true);
}
// Free EVR
EvrDeinit(_presenterInstance);
FreeEvrCallback();
FilterGraphTools.TryRelease(ref _evr);
FilterGraphTools.TryDispose(ref _rot);
FilterGraphTools.TryRelease(ref _graphBuilder);
}
/// <summary>
/// Frees the audio/video codecs.
/// </summary>
protected override void FreeCodecs()
{
// Release stream selectors
ReleaseStreamSelectors();
// Free EVR
SafeEvrDeinit();
FreeEvrCallback();
FilterGraphTools.TryRelease(ref _evr);
base.FreeCodecs();
// Free all filters from graph
if (_graphBuilder != null)
{
FilterGraphTools.RemoveAllFilters(_graphBuilder, true);
}
FilterGraphTools.TryDispose(ref _mpcSubsRenderer);
FilterGraphTools.TryDispose(ref _rot);
FilterGraphTools.TryRelease(ref _graphBuilder, true);
}
protected override void Decompose()
{
if (this.graphBuilder != null)
{
int hr = 0;
OnGraphEnded();
// Decompose the graph
try { hr = (this.graphBuilder as IMediaControl).StopWhenReady(); }
catch { }
try { hr = (this.graphBuilder as IMediaControl).Stop(); }
catch { }
RemoveHandlers();
FilterGraphTools.RemoveAllFilters(this.graphBuilder);
if (this.audioRenderer != null)
{
Marshal.ReleaseComObject(this.audioRenderer);
}
this.audioRenderer = null;
if (this.videoRenderer != null)
{
Marshal.ReleaseComObject(this.videoRenderer);
}
this.videoRenderer = null;
if (this.captureGraphBuilder != null)
{
Marshal.ReleaseComObject(this.captureGraphBuilder);
}
this.captureGraphBuilder = null;
try { rot.Dispose(); }
catch { }
try { Marshal.ReleaseComObject(this.graphBuilder); this.graphBuilder = null; }
catch { }
}
}
/// <summary>
/// Decompose the graph and release resources.
/// </summary>
public virtual void Dispose()
{
FilterState filterState;
mediaControl.GetState(0, out filterState);
if (filterState != FilterState.Stopped)
{
LogMessage("Stopping graph");
reply = mediaControl.Stop();
DsError.ThrowExceptionForHR(reply);
}
LogMessage("Removing filters");
FilterGraphTools.RemoveAllFilters(graphBuilder);
LogMessage("Releasing Graph Builder");
Marshal.ReleaseComObject(graphBuilder);
graphBuilder = null;
LogMessage("Releasing Capture Builder");
Marshal.ReleaseComObject(captureBuilder);
captureBuilder = null;
}
private void Decompose()
{
int hr = 0;
// Decompose the graph
hr = (this.graphBuilder as IMediaControl).StopWhenReady();
hr = (this.graphBuilder as IMediaControl).Stop();
FilterGraphTools.RemoveAllFilters(this.graphBuilder);
Marshal.ReleaseComObject(this.networkProvider); this.networkProvider = null;
Marshal.ReleaseComObject(this.mpeg2Demux); this.mpeg2Demux = null;
Marshal.ReleaseComObject(this.tuner); this.tuner = null;
Marshal.ReleaseComObject(this.capture); this.capture = null;
Marshal.ReleaseComObject(this.bdaTIF); this.bdaTIF = null;
Marshal.ReleaseComObject(this.bdaSecTab); this.bdaSecTab = null;
Marshal.ReleaseComObject(this.audioRenderer); this.audioRenderer = null;
Marshal.ReleaseComObject(this.videoRenderer); this.videoRenderer = null;
rot.Dispose();
Marshal.ReleaseComObject(this.graphBuilder); this.graphBuilder = null;
}
private void HandleGraphEvent()
{
EventCode evCode;
IntPtr evParam1, evParam2;
if (mediaEventEx == null)
{
return;
}
while (mediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
{
mediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
if (evCode == EventCode.Complete)
{
mediaControl.Stop();
FilterGraphTools.RemoveAllFilters(graphBuilder);
CloseInterfaces();
OnPlayerCompleted();
}
}
}
/// <summary>
/// Clean up, dispose, release.
/// </summary>
public void Dispose()
{
Stop();
if (_rwsTuner != null)
{
_rwsTuner.Dispose();
_rwsTuner = null;
}
if (_rotEntry != null)
{
_rotEntry.Dispose();
}
if (_graphBuilder != null)
{
FilterGraphTools.RemoveAllFilters(_graphBuilder);
Release.ComObject("device detection graph builder", _graphBuilder);
}
Release.ComObject("device detection ATSC network provider", _atscNp);
Release.ComObject("device detection DVB-C network provider", _dvbcNp);
Release.ComObject("device detection DVB-S network provider", _dvbsNp);
Release.ComObject("device detection DVB-T network provider", _dvbtNp);
Release.ComObject("device detection MediaPortal network provider", _mpNp);
}
public virtual void Dispose(bool disposing)
{
lock (_graphStateLock)
{
GC.SuppressFinalize(this);
if (disposing)
{
FilterGraphTools.RemoveAllFilters(_graphBuilder);
if (_graphBuilder != null)
{
int refCount;
do
{
refCount = Marshal.ReleaseComObject(_graphBuilder);
} while (refCount > 0);
_graphBuilder = null;
_mediaControl = null;
}
if (_captureGraphBuilder != null)
{
int refCount;
do
{
refCount = Marshal.ReleaseComObject(_captureGraphBuilder);
} while (refCount > 0);
_captureGraphBuilder = null;
}
if (_abortTimer != null)
{
_abortTimer.Elapsed -= new System.Timers.ElapsedEventHandler(AbortTimer_Elapsed);
_abortTimer.Dispose();
_abortTimer = null;
}
}
}
}
/// <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());
}
private void handleInternalNetworkProviderFilter(DsDevice[] devices, IFilterGraph2 graphBuilder,
Guid networkProviderClsId, DsROTEntry rotEntry)
{
IDvbNetworkProvider interfaceNetworkProvider;
TuningType tuningTypes;
for (int i = 0; i < devices.Length; i++)
{
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;
graphBuilder.AddSourceFilterForMoniker(devices[i].Mon, null, name, out tmp);
//Use the Microsoft Network Provider method first but only if available
IBaseFilter networkDVB = FilterGraphTools.AddFilterFromClsid(graphBuilder, networkProviderClsId,
"MediaPortal Network Provider");
interfaceNetworkProvider = (IDvbNetworkProvider)networkDVB;
string hash = GetHash(devices[i].DevicePath);
interfaceNetworkProvider.ConfigureLogging(GetFileName(devices[i].DevicePath), hash, LogLevelOption.Debug);
if (ConnectFilter(graphBuilder, networkDVB, tmp))
{
Log.Log.WriteFile("Detected DVB card:{0}- Hash: {1}", name, hash);
interfaceNetworkProvider.GetAvailableTuningTypes(out tuningTypes);
Log.Log.WriteFile("TuningTypes: " + tuningTypes);
// determine the DVB card supported GUIDs here!
if ((tuningTypes & TuningType.DvbT) != 0 && !isCablePreferred)
{
Log.Log.WriteFile("Detected DVB-T* card:{0}", name);
TvCardDVBT dvbtCard = new TvCardDVBT(_epgEvents, devices[i]);
_cards.Add(dvbtCard);
}
if ((tuningTypes & TuningType.DvbS) != 0 && !isCablePreferred)
{
Log.Log.WriteFile("Detected DVB-S* card:{0}", name);
TvCardDVBS dvbsCard = new TvCardDVBS(_epgEvents, devices[i]);
_cards.Add(dvbsCard);
}
if ((tuningTypes & TuningType.DvbC) != 0)
{
Log.Log.WriteFile("Detected DVB-C* card:{0}", name);
TvCardDVBC dvbcCard = new TvCardDVBC(_epgEvents, devices[i]);
_cards.Add(dvbcCard);
}
if ((tuningTypes & TuningType.Atsc) != 0 && !isCablePreferred)
{
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);
graphBuilder.RemoveFilter(networkDVB);
Release.ComObject("ms provider", networkDVB);
}
FilterGraphTools.RemoveAllFilters(graphBuilder);
rotEntry.Dispose();
Release.ComObject("graph builder", graphBuilder);
}
/// <summary>
/// Builds the graph.
/// </summary>
public override void BuildGraph()
{
try
{
Log.Log.WriteFile("b2c2: build graph");
if (_graphState != GraphState.Idle)
{
Log.Log.Error("b2c2: Graph already built");
throw new TvException("Graph already built");
}
DevicesInUse.Instance.Add(_tunerDevice);
_managedThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
_graphBuilder = (IFilterGraph2) new FilterGraph();
_rotEntry = new DsROTEntry(_graphBuilder);
_capBuilder = (ICaptureGraphBuilder2) new CaptureGraphBuilder2();
_capBuilder.SetFiltergraph(_graphBuilder);
//=========================================================================================================
// add the B2C2 specific filters
//=========================================================================================================
Log.Log.WriteFile("b2c2:CreateGraph() create B2C2 adapter");
_filterB2C2Adapter =
Activator.CreateInstance(Type.GetTypeFromCLSID(CLSID_B2C2Adapter, false)) as IBaseFilter;
Log.Log.WriteFile("b2c2: Filter instance: " + _filterB2C2Adapter);
if (_filterB2C2Adapter == null)
{
Log.Log.Error("b2c2:creategraph() _filterB2C2Adapter not found");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
Log.Log.WriteFile("b2c2:creategraph() add filters to graph");
int hr = _graphBuilder.AddFilter(_filterB2C2Adapter, "B2C2-Source");
if (hr != 0)
{
Log.Log.Error("b2c2: FAILED to add B2C2-Adapter");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
// get interfaces
_interfaceB2C2TunerCtrl = _filterB2C2Adapter as IB2C2MPEG2TunerCtrl4;
if (_interfaceB2C2TunerCtrl == null)
{
Log.Log.Error("b2c2: cannot get IB2C2MPEG2TunerCtrl4");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
_interfaceB2C2DataCtrl = _filterB2C2Adapter as IB2C2MPEG2DataCtrl6;
if (_interfaceB2C2DataCtrl == null)
{
Log.Log.Error("b2c2: cannot get IB2C2MPEG2DataCtrl6");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
hr = _interfaceB2C2DataCtrl.SelectDevice(_deviceInfo.DeviceId);
if (hr != 0)
{
Log.Log.Error("b2c2: select device failed: {0:X}", hr);
}
//=========================================================================================================
// initialize B2C2 tuner
//=========================================================================================================
Log.Log.WriteFile("b2c2: Initialize Tuner()");
hr = _interfaceB2C2TunerCtrl.Initialize();
if (hr != 0)
{
//System.Diagnostics.Debugger.Launch();
Log.Log.Error("b2c2: Tuner initialize failed:0x{0:X}", hr);
// if the B2C2 card is detected as analogue, it needs a device reset
((IMediaControl)_graphBuilder).Stop();
FreeAllSubChannels();
FilterGraphTools.RemoveAllFilters(_graphBuilder);
if (_graphBuilder != null)
{
Release.ComObject("graph builder", _graphBuilder);
_graphBuilder = null;
}
if (_capBuilder != null)
{
Release.ComObject("capBuilder", _capBuilder);
_capBuilder = null;
}
DevicesInUse.Instance.Remove(_tunerDevice);
CardPresent = false;
return;
}
// call checklock once, the return value dont matter
hr = _interfaceB2C2TunerCtrl.CheckLock();
AddTsWriterFilterToGraph();
IBaseFilter lastFilter;
ConnectInfTeeToB2C2(out lastFilter);
AddMdPlugs(ref lastFilter);
if (!ConnectTsWriter(lastFilter))
{
throw new TvExceptionGraphBuildingFailed("Graph building failed");
}
SendHwPids(new List <ushort>());
_graphState = GraphState.Created;
}
catch (Exception ex)
{
Log.Log.Write(ex);
Dispose();
_graphState = GraphState.Idle;
throw new TvExceptionGraphBuildingFailed("Graph building failed", ex);
}
}
/// <summary>
/// Disposes this instance.
/// </summary>
public virtual void Dispose()
{
if (_graphBuilder == null)
{
return;
}
Log.Log.WriteFile("HDPVR: Dispose()");
if (_graphState == GraphState.TimeShifting || _graphState == GraphState.Recording)
{
// Stop the graph first. To ensure that the timeshift files are no longer blocked
StopGraph();
}
FreeAllSubChannels();
// Decompose the graph
IMediaControl mediaCtl = (_graphBuilder as IMediaControl);
if (mediaCtl == null)
{
throw new TvException("Can not convert graphBuilder to IMediaControl");
}
// Decompose the graph
mediaCtl.Stop();
FilterGraphTools.RemoveAllFilters(_graphBuilder);
Log.Log.WriteFile("HDPVR: All filters removed");
if (_filterCrossBar != null)
{
while (Release.ComObject(_filterCrossBar) > 0)
{
}
_filterCrossBar = null;
}
if (_filterCapture != null)
{
while (Release.ComObject(_filterCapture) > 0)
{
}
_filterCapture = null;
}
if (_filterEncoder != null)
{
while (Release.ComObject(_filterEncoder) > 0)
{
}
_filterEncoder = null;
}
if (_filterTsWriter != null)
{
while (Release.ComObject(_filterTsWriter) > 0)
{
}
_filterTsWriter = null;
}
_rotEntry.Dispose();
Release.ComObject("Graphbuilder", _graphBuilder);
_graphBuilder = null;
DevicesInUse.Instance.Remove(_tunerDevice);
_graphState = GraphState.Idle;
if (_crossBarDevice != null)
{
DevicesInUse.Instance.Remove(_crossBarDevice);
_crossBarDevice = null;
}
if (_captureDevice != null)
{
DevicesInUse.Instance.Remove(_captureDevice);
_captureDevice = null;
}
if (_encoderDevice != null)
{
DevicesInUse.Instance.Remove(_encoderDevice);
_encoderDevice = null;
}
_graphState = GraphState.Idle;
Log.Log.WriteFile("HDPVR: dispose completed");
}
/// <summary>
/// Disposes this instance.
/// </summary>
public virtual void Dispose()
{
if (_graphBuilder == null)
{
return;
}
Log.Log.WriteFile("analog:Dispose()");
if (!CheckThreadId())
{
return;
}
if (_graphState == GraphState.TimeShifting || _graphState == GraphState.Recording)
{
// Stop the graph first. To ensure that the timeshift files are no longer blocked
StopGraph();
}
FreeAllSubChannels();
IMediaControl mediaCtl = (_graphBuilder as IMediaControl);
if (mediaCtl == null)
{
throw new TvException("Can not convert graphBuilder to IMediaControl");
}
// Decompose the graph
mediaCtl.Stop();
FilterGraphTools.RemoveAllFilters(_graphBuilder);
Log.Log.WriteFile("analog:All filters removed");
if (_tuner != null)
{
_tuner.Dispose();
_tuner = null;
_tunerDevice = null;
}
if (_crossbar != null)
{
_crossbar.Dispose();
_crossbar = null;
}
if (_tvAudio != null)
{
_tvAudio.Dispose();
_tvAudio = null;
}
if (_capture != null)
{
_capture.Dispose();
_capture = null;
}
if (_encoder != null)
{
_encoder.Dispose();
_encoder = null;
}
if (_teletext != null)
{
_teletext.Dispose();
_teletext = null;
}
if (_tsFileSink != null)
{
Release.ComObject("tsFileSink filter", _tsFileSink);
_tsFileSink = null;
}
_rotEntry.Dispose();
_rotEntry = null;
Release.ComObject("Graphbuilder", _graphBuilder);
_graphBuilder = null;
_graphState = GraphState.Idle;
Log.Log.WriteFile("analog: dispose completed");
}
/// <summary>
/// Builds the graph.
/// </summary>
public override void BuildGraph()
{
try
{
Log.Log.WriteFile("ss2: build graph");
if (_graphState != GraphState.Idle)
{
Log.Log.Error("ss2: Graph already built");
throw new TvException("Graph already built");
}
DevicesInUse.Instance.Add(_tunerDevice);
_managedThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
_graphBuilder = (IFilterGraph2) new FilterGraph();
_rotEntry = new DsROTEntry(_graphBuilder);
_capBuilder = (ICaptureGraphBuilder2) new CaptureGraphBuilder2();
_capBuilder.SetFiltergraph(_graphBuilder);
//=========================================================================================================
// add the skystar 2 specific filters
//=========================================================================================================
Log.Log.WriteFile("ss2:CreateGraph() create B2C2 adapter");
_filterB2C2Adapter =
(IBaseFilter)Activator.CreateInstance(Type.GetTypeFromCLSID(DVBSkyStar2Helper.CLSID_B2C2Adapter, false));
if (_filterB2C2Adapter == null)
{
Log.Log.Error("ss2:creategraph() _filterB2C2Adapter not found");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
Log.Log.WriteFile("ss2:creategraph() add filters to graph");
int hr = _graphBuilder.AddFilter(_filterB2C2Adapter, "B2C2-Source");
if (hr != 0)
{
Log.Log.Error("ss2: FAILED to add B2C2-Adapter");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
// get interfaces
_interfaceB2C2DataCtrl = _filterB2C2Adapter as DVBSkyStar2Helper.IB2C2MPEG2DataCtrl3;
if (_interfaceB2C2DataCtrl == null)
{
Log.Log.Error("ss2: cannot get IB2C2MPEG2DataCtrl3");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
_interfaceB2C2TunerCtrl = _filterB2C2Adapter as DVBSkyStar2Helper.IB2C2MPEG2TunerCtrl2;
if (_interfaceB2C2TunerCtrl == null)
{
Log.Log.Error("ss2: cannot get IB2C2MPEG2TunerCtrl3");
DevicesInUse.Instance.Remove(_tunerDevice);
return;
}
//=========================================================================================================
// initialize skystar 2 tuner
//=========================================================================================================
Log.Log.WriteFile("ss2: Initialize Tuner()");
hr = _interfaceB2C2TunerCtrl.Initialize();
if (hr != 0)
{
//System.Diagnostics.Debugger.Launch();
Log.Log.Error("ss2: Tuner initialize failed:0x{0:X}", hr);
// if the skystar2 card is detected as analogue, it needs a device reset
((IMediaControl)_graphBuilder).Stop();
FreeAllSubChannels();
FilterGraphTools.RemoveAllFilters(_graphBuilder);
if (_graphBuilder != null)
{
Release.ComObject("graph builder", _graphBuilder);
_graphBuilder = null;
}
if (_capBuilder != null)
{
Release.ComObject("capBuilder", _capBuilder);
_capBuilder = null;
}
DevicesInUse.Instance.Remove(_tunerDevice);
/*
* if (initResetTries == 0)
* {
* Log.Log.Error("ss2: resetting driver");
* HardwareHelperLib.HH_Lib hwHelper = new HardwareHelperLib.HH_Lib();
* string[] deviceDriverName = new string[1];
* deviceDriverName[0] = DEVICE_DRIVER_NAME;
* hwHelper.SetDeviceState(deviceDriverName, false);
* hwHelper.SetDeviceState(deviceDriverName, true);
* initResetTries++;
*
* BuildGraph();
* }
* else
* {
* Log.Log.Error("ss2: resetting driver did not help");
* CardPresent = false;
* }
*/
CardPresent = false;
return;
}
// call checklock once, the return value dont matter
_interfaceB2C2TunerCtrl.CheckLock();
AddTsWriterFilterToGraph();
IBaseFilter lastFilter;
ConnectInfTeeToSS2(out lastFilter);
AddMdPlugs(ref lastFilter);
if (!ConnectTsWriter(lastFilter))
{
throw new TvExceptionGraphBuildingFailed("Graph building failed");
}
SendHwPids(new List <ushort>());
_graphState = GraphState.Created;
}
catch (Exception ex)
{
Log.Log.Write(ex);
Dispose();
_graphState = GraphState.Idle;
throw new TvExceptionGraphBuildingFailed("Graph building failed", ex);
}
}
protected override void Decompose()
{
if (this.graphBuilder != null)
{
int hr = 0;
OnGraphEnded();
this.epg.UnRegisterEvent();
// Decompose the graph
try { hr = (this.graphBuilder as IMediaControl).StopWhenReady(); }
catch { }
try { hr = (this.graphBuilder as IMediaControl).Stop(); }
catch { }
try { hr = (this.graphBuilder2 as IMediaControl).StopWhenReady(); }
catch { }
try { hr = (this.graphBuilder2 as IMediaControl).Stop(); }
catch { }
RemoveHandlers();
FilterGraphTools.RemoveAllFilters(this.graphBuilder);
FilterGraphTools.RemoveAllFilters(this.graphBuilder2);
if (this.networkProvider != null)
{
Marshal.ReleaseComObject(this.networkProvider);
}
this.networkProvider = null;
if (this.mpeg2Demux != null)
{
Marshal.ReleaseComObject(this.mpeg2Demux);
}
this.mpeg2Demux = null;
if (this.mpeg2VideoStreamAnalyzer != null)
{
Marshal.ReleaseComObject(this.mpeg2VideoStreamAnalyzer);
}
this.mpeg2VideoStreamAnalyzer = null;
if (this.tuner != null)
{
Marshal.ReleaseComObject(this.tuner);
}
this.tuner = null;
if (this.capture != null)
{
Marshal.ReleaseComObject(this.capture);
}
this.capture = null;
if (this.bdaTIF != null)
{
Marshal.ReleaseComObject(this.bdaTIF);
}
this.bdaTIF = null;
if (this.bdaSecTab != null)
{
Marshal.ReleaseComObject(this.bdaSecTab);
}
this.bdaSecTab = null;
if (this.audioDecoderFilter != null)
{
Marshal.ReleaseComObject(this.audioDecoderFilter);
}
this.audioDecoderFilter = null;
if (this.videoH264DecoderFilter != null)
{
Marshal.ReleaseComObject(this.videoH264DecoderFilter);
}
this.videoH264DecoderFilter = null;
if (this.videoMpeg2DecoderFilter != null)
{
Marshal.ReleaseComObject(this.videoMpeg2DecoderFilter);
}
this.videoMpeg2DecoderFilter = null;
if (this.audioRenderer != null)
{
Marshal.ReleaseComObject(this.audioRenderer);
}
this.audioRenderer = null;
if (this.videoRenderer != null)
{
Marshal.ReleaseComObject(this.videoRenderer);
}
this.videoRenderer = null;
if (this.captureGraphBuilder != null)
{
Marshal.ReleaseComObject(this.captureGraphBuilder);
}
this.captureGraphBuilder = null;
if (this.streamBufferSink != null)
{
Marshal.ReleaseComObject(this.streamBufferSink);
}
this.streamBufferSink = null;
if (this.streamBufferSource != null)
{
Marshal.ReleaseComObject(this.streamBufferSource);
}
this.streamBufferSource = null;
if (streamBufferConfigHKey != IntPtr.Zero)
{
RegCloseKey(streamBufferConfigHKey);
streamBufferConfigHKey = IntPtr.Zero;
}
try { rot.Dispose(); }
catch { }
try { Marshal.ReleaseComObject(this.graphBuilder); this.graphBuilder = null; }
catch { }
try { rot2.Dispose(); }
catch { }
try { Marshal.ReleaseComObject(this.graphBuilder2); this.graphBuilder2 = null; }
catch { }
}
}
