private void cmdScanTuners_Click(object sender, EventArgs e)
{
cboTuners.Items.Clear();
BDAGraph.LoadTuners();
if (!Tuner.TunerPresent)
{
Logger.Instance.Write("No tuners detected");
MessageBox.Show("No Tuners detected!", "Warning...", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
ObservableCollection <Tuner> tuners = Tuner.TunerCollection;
foreach (Tuner item in tuners)
{
this.cboTuners.Items.Add(item.Name);
}
if (cboTuners.Items.Count > 0)
{
cboTuners.SelectedIndex = 0;
}
}
}
private void getData(BDAGraph graph, DumpParameters dumpParameters, BackgroundWorker worker)
{
Logger.Instance.Write(string.Format("Starting dump to {0}", dumpParameters.FileName));
int[] newPids;
if (dumpParameters.PidList != null && dumpParameters.PidList.Count != 0)
{
newPids = new int[dumpParameters.PidList.Count];
for (int index = 0; index < dumpParameters.PidList.Count; index++)
{
newPids[index] = dumpParameters.PidList[index];
}
}
else
{
newPids = new int[1];
newPids[0] = -1;
}
graph.ChangePidMapping(newPids);
DateTime startTime = DateTime.Now;
int lastSize = 0;
while (!worker.CancellationPending)
{
Thread.Sleep(100);
int increment = 5;
if (dumpParameters.PidList != null && dumpParameters.PidList.Count != 0)
{
increment = 1;
}
int buffer_space = graph.BufferSpaceUsed / (1024 * 1024);
if (buffer_space > 40)
{
graph.clear_buffer();
}
int size = graph.DumpFileSize / (1024 * 1024);
if (size >= lastSize + increment)
{
Logger.Instance.Write("Record/Buffer sizes: (" + size + "/" + buffer_space + ")");
worker.ReportProgress((int)size);
lastSize = size;
}
}
finalSize = graph.DumpFileSize;
Logger.Instance.Write("Dump completed - file size now " + finalSize + " bytes");
}
public MainWindow()
{
InitializeComponent();
Logger.Instance.WriteSeparator("TSDumper (Version " + RunParameters.SystemVersion + ")");
Logger.Instance.Write("Executable build: " + AssemblyVersion);
Logger.Instance.Write("DirectShow build: " + DirectShowGraph.AssemblyVersion);
Logger.Instance.Write("DomainObjects build: " + RunParameters.AssemblyVersion);
Logger.Instance.Write("DVBServices build: " + Utils.AssemblyVersion);
Logger.Instance.Write("");
Logger.Instance.Write("Privilege level: " + RunParameters.Role);
Logger.Instance.Write("");
Logger.Instance.Write("Base directory: " + RunParameters.BaseDirectory);
Logger.Instance.Write("Data directory: " + RunParameters.DataDirectory);
Logger.Instance.Write("");
mainWindow = this;
BDAGraph.LoadTuners();
if (Tuner.TunerCollection.Count == 0)
{
MessageBox.Show("There are no tuners installed on this machine.", "TSDumper", MessageBoxButtons.OK,
MessageBoxIcon.Error);
Environment.Exit(10);
}
if (tsDumpControl == null)
{
tsDumpControl = new TransportStreamDumpControl();
positionControl(tsDumpControl);
}
this.Text = tsDumpControl.Heading;
tsDumpControl.Tag = new ControlStatus(this.Text);
Cursor.Current = Cursors.WaitCursor;
tsDumpControl.Process();
Cursor.Current = Cursors.Arrow;
Logger.Instance.Write("TSDumper is loaded");
}
private void backgroundWorkerScanStations_DoScan(object sender, DoWorkEventArgs e)
{
//// The sender is the BackgroundWorker object we need it to
//// report progress and check for cancellation.
//BackgroundWorker bwAsync = sender as BackgroundWorker;
try
{
if (ConfigSettings.ScanningFrequency.Frequency < 1)
{
Logger.Instance.Write("Incorrect or Missing ScanningFrequency");
MessageBox.Show("Incorrect or Missing ScanningFrequency", "Warning...");
}
else
{
BDAGraph.LoadTuners();
if (!Tuner.TunerPresent)
{
Logger.Instance.Write("No tuners detected");
MessageBox.Show("No Tuners detected!", "Warning...", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
if (!getStations(ConfigSettings.ScanningFrequency))
{
Logger.Instance.Write("No Stations detected");
MessageBox.Show("No Stations detected - check signal & frequencies", "Warning...");
}
}
}
}
catch (Exception x)
{
Console.Write("");
}
}
private static bool tuneFrequency(TuningFrequency frequency)
{
Logger.Instance.Write("Tuning to frequency " + frequency.Frequency + " on " + frequency.TunerType);
TuningSpec tuningSpec;
TunerNodeType tunerNodeType;
int frequencyRetries = 0;
if (frequency.TunerType == TunerType.Satellite)
{
tuningSpec = new TuningSpec(Satellite.CurrentSatellite, (SatelliteFrequency)frequency);
tunerNodeType = TunerNodeType.Satellite;
}
else if (frequency.TunerType == TunerType.Terrestrial)
{
tuningSpec = new TuningSpec((TerrestrialFrequency)frequency);
tunerNodeType = TunerNodeType.Terrestrial;
}
else
{
tuningSpec = new TuningSpec((CableFrequency)frequency);
tunerNodeType = TunerNodeType.Cable;
}
bool finished = false;
while (!finished)
{
graph = BDAGraph.FindTuner(RunParameters.SelectedTuner, tunerNodeType, tuningSpec);
if (graph == null)
{
Logger.Instance.Write("Tuner not available");
return(false);
}
TimeSpan timeout = new TimeSpan();
bool done = false;
bool locked = false;
if (RunParameters.Options.Contains("NOSIGLOCK"))
{
Logger.Instance.Write("Option NOSIGLOCK: No lock check, wait 5 seconds instead");
locked = true;
Thread.Sleep(5000);
}
else
{
while (!done)
{
if (cancelGraph)
{
graph.Dispose();
return(false);
}
locked = graph.SignalLocked;
if (!locked)
{
int signalQuality = graph.SignalQuality;
if (signalQuality > 0)
{
Logger.Instance.Write("Signal not locked but signal quality > 0");
locked = true;
done = true;
}
else
{
Logger.Instance.Write("Signal not locked and signal quality not > 0");
Thread.Sleep(1000);
timeout = timeout.Add(new TimeSpan(0, 0, 1));
done = (timeout.TotalSeconds == RunParameters.LockTimeout.TotalSeconds);
}
}
else
{
done = true;
}
}
}
if (!locked)
{
Logger.Instance.Write("Failed to acquire signal");
graph.Dispose();
if (frequencyRetries == 1)
{
return(false);
}
else
{
frequencyRetries++;
Logger.Instance.Write("Retrying frequency");
}
}
else
{
finished = true;
Logger.Instance.Write("Signal acquired: lock is " + graph.SignalLocked + " quality is " + graph.SignalQuality + " strength is " + graph.SignalStrength);
}
}
return(true);
}
private string checkTuning(BDAGraph graph, AnalysisParameters analysisParameters, BackgroundWorker worker)
{
TimeSpan timeout = new TimeSpan();
bool done = false;
bool locked = false;
int frequencyRetries = 0;
while (!done)
{
if (worker.CancellationPending)
{
Logger.Instance.Write("Analysis abandoned by user");
return(null);
}
locked = graph.SignalLocked;
if (!locked)
{
int signalQuality = graph.SignalQuality;
if (signalQuality > 0)
{
Logger.Instance.Write("Signal not locked but signal quality > 0");
locked = true;
done = true;
}
else
{
if (!analysisParameters.UseSignalPresent)
{
Logger.Instance.Write("Signal not locked and signal quality not > 0");
Thread.Sleep(1000);
timeout = timeout.Add(new TimeSpan(0, 0, 1));
done = (timeout.TotalSeconds == analysisParameters.SignalLockTimeout);
}
else
{
bool signalPresent = graph.SignalPresent;
if (signalPresent)
{
Logger.Instance.Write("Signal present");
locked = true;
done = true;
}
else
{
Logger.Instance.Write("Signal not present");
Thread.Sleep(1000);
timeout = timeout.Add(new TimeSpan(0, 0, 1));
done = (timeout.TotalSeconds == analysisParameters.SignalLockTimeout);
}
}
if (done)
{
done = (frequencyRetries == 2);
if (done)
{
Logger.Instance.Write("<e> Failed to acquire signal");
}
else
{
Logger.Instance.Write("Retrying frequency");
timeout = new TimeSpan();
frequencyRetries++;
}
}
}
}
else
{
Logger.Instance.Write("Signal acquired: lock is " + graph.SignalLocked + " quality is " + graph.SignalQuality + " strength is " + graph.SignalStrength);
done = true;
}
}
if (locked)
{
return(null);
}
else
{
return("<e> The tuner failed to acquire a signal for frequency " + analysisParameters.ScanningFrequency.ToString());
}
}
private void doAnalysis(object sender, DoWorkEventArgs e)
{
AnalysisParameters analysisParameters = e.Argument as AnalysisParameters;
pidList = null;
TunerNodeType tunerNodeType;
TuningSpec tuningSpec;
SatelliteFrequency satelliteFrequency = analysisParameters.ScanningFrequency as SatelliteFrequency;
if (satelliteFrequency != null)
{
tunerNodeType = TunerNodeType.Satellite;
tuningSpec = new TuningSpec((Satellite)satelliteFrequency.Provider, satelliteFrequency);
}
else
{
TerrestrialFrequency terrestrialFrequency = analysisParameters.ScanningFrequency as TerrestrialFrequency;
if (terrestrialFrequency != null)
{
tunerNodeType = TunerNodeType.Terrestrial;
tuningSpec = new TuningSpec(terrestrialFrequency);
}
else
{
CableFrequency cableFrequency = analysisParameters.ScanningFrequency as CableFrequency;
if (cableFrequency != null)
{
tunerNodeType = TunerNodeType.Cable;
tuningSpec = new TuningSpec(cableFrequency);
}
else
{
AtscFrequency atscFrequency = analysisParameters.ScanningFrequency as AtscFrequency;
if (atscFrequency != null)
{
if (atscFrequency.TunerType == TunerType.ATSC)
{
tunerNodeType = TunerNodeType.ATSC;
}
else
{
tunerNodeType = TunerNodeType.Cable;
}
tuningSpec = new TuningSpec(atscFrequency);
}
else
{
ClearQamFrequency clearQamFrequency = analysisParameters.ScanningFrequency as ClearQamFrequency;
if (clearQamFrequency != null)
{
tunerNodeType = TunerNodeType.Cable;
tuningSpec = new TuningSpec(clearQamFrequency);
}
else
{
ISDBSatelliteFrequency isdbSatelliteFrequency = analysisParameters.ScanningFrequency as ISDBSatelliteFrequency;
if (isdbSatelliteFrequency != null)
{
tunerNodeType = TunerNodeType.ISDBS;
tuningSpec = new TuningSpec((Satellite)satelliteFrequency.Provider, isdbSatelliteFrequency);
}
else
{
ISDBTerrestrialFrequency isdbTerrestrialFrequency = analysisParameters.ScanningFrequency as ISDBTerrestrialFrequency;
if (isdbTerrestrialFrequency != null)
{
tunerNodeType = TunerNodeType.ISDBT;
tuningSpec = new TuningSpec(isdbTerrestrialFrequency);
}
else
{
throw (new InvalidOperationException("Tuning frequency not recognized"));
}
}
}
}
}
}
}
Tuner currentTuner = null;
bool finished = false;
while (!finished)
{
if ((sender as BackgroundWorker).CancellationPending)
{
Logger.Instance.Write("Scan abandoned by user");
e.Cancel = true;
resetEvent.Set();
return;
}
BDAGraph graph = BDAGraph.FindTuner(analysisParameters.Tuners, tunerNodeType, tuningSpec, currentTuner, analysisParameters.RepeatDiseqc, analysisParameters.SwitchAfterPlay);
if (graph == null)
{
Logger.Instance.Write("<e> No tuner able to tune frequency " + analysisParameters.ScanningFrequency.ToString());
frequencySelectionControl.Invoke(new ShowMessage(showMessage), "No tuner able to tune frequency " + analysisParameters.ScanningFrequency.ToString(),
MessageBoxButtons.OK, MessageBoxIcon.Error);
finished = true;
}
else
{
string tuneReply = checkTuning(graph, analysisParameters, sender as BackgroundWorker);
if ((sender as BackgroundWorker).CancellationPending)
{
Logger.Instance.Write("Scan abandoned by user");
graph.Dispose();
e.Cancel = true;
resetEvent.Set();
return;
}
if (tuneReply == null)
{
try
{
if (analysisParameters.DumpFileName == null || analysisParameters.DumpFileName == string.Empty)
{
getData(graph, analysisParameters, sender as BackgroundWorker);
}
else
{
SimulationDataProvider dataProvider = new SimulationDataProvider(analysisParameters.DumpFileName, graph.Frequency);
string providerReply = dataProvider.Run();
if (providerReply != null)
{
Logger.Instance.Write("<e> Simulation Data Provider failed");
Logger.Instance.Write("<e> " + providerReply);
frequencySelectionControl.Invoke(new ShowMessage(showMessage), "Simulation Data Provider failed." +
Environment.NewLine + Environment.NewLine + providerReply,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
getData(dataProvider, analysisParameters, sender as BackgroundWorker);
dataProvider.Stop();
}
}
}
catch (IOException ex)
{
Logger.Instance.Write("<e> Failed to process dump file");
Logger.Instance.Write("<e> " + ex.Message);
frequencySelectionControl.Invoke(new ShowMessage(showMessage), "Failed to process dump file." +
Environment.NewLine + Environment.NewLine + ex.Message,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
graph.Dispose();
finished = true;
}
else
{
Logger.Instance.Write("Failed to tune frequency " + analysisParameters.ScanningFrequency.ToString());
graph.Dispose();
currentTuner = graph.Tuner;
}
}
}
e.Cancel = true;
resetEvent.Set();
}
