732 lines
30 KiB
C#
732 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.InteropServices;
|
|
using skyscraper5.Abertis;
|
|
using skyscraper5.Hdmv;
|
|
using skyscraper5.Mpeg2;
|
|
using skyscraper5.Scorcher;
|
|
using skyscraper5.Skyscraper;
|
|
using skyscraper5.Skyscraper.Gps;
|
|
using skyscraper5.Skyscraper.IO;
|
|
using skyscraper5.Skyscraper.IO.CrazycatStreamReader;
|
|
using skyscraper5.Skyscraper.IO.TunerInterface;
|
|
using skyscraper5.Skyscraper.Plugins;
|
|
using skyscraper5.Skyscraper.RecordingImporter;
|
|
using skyscraper5.Skyscraper.Scraper;
|
|
using skyscraper5.Skyscraper.Scraper.FrameGrabber;
|
|
using skyscraper5.Skyscraper.Scraper.Storage;
|
|
using skyscraper5.Skyscraper.Scraper.Storage.Filesystem;
|
|
using skyscraper5.Skyscraper.Scraper.Storage.InMemory;
|
|
using skyscraper5.Skyscraper.Webserver;
|
|
using skyscraper5.src.Aac;
|
|
using skyscraper5.src.Skyscraper.FrequencyListGenerator;
|
|
using skyscraper5.T2MI;
|
|
using skyscraper5.src.Mpeg2.PacketFilter;
|
|
using skyscraper8.Skyscraper.IO;
|
|
using log4net;
|
|
|
|
[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config")]
|
|
namespace skyscraper5
|
|
{
|
|
class Program
|
|
{
|
|
private static readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name);
|
|
|
|
static void Main(string[] args)
|
|
{
|
|
logger.Info("Hello!");
|
|
ffmpegFrameGrabber.CanStart();
|
|
logger.DebugFormat("Found {0}-bit Operating system.", Environment.Is64BitOperatingSystem ? 64 : 32);
|
|
logger.DebugFormat("I'm a {0}-bit Process.", Environment.Is64BitProcess ? 64 : 32);
|
|
|
|
PluginManager.GetInstance();
|
|
|
|
if (args.Length != 0)
|
|
{
|
|
if (args[0].ToLowerInvariant().EndsWith(".ts"))
|
|
{
|
|
FileInfo fi = new FileInfo(args[0]);
|
|
if (fi.Exists)
|
|
HandleSingleFile(fi);
|
|
else
|
|
Console.WriteLine("{0} missing.", fi.FullName);
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().EndsWith(".m3u8"))
|
|
{
|
|
M3U8Stream m3U8Stream = new M3U8Stream(args[0]);
|
|
SkyscraperContext skyscraperContext = new SkyscraperContext(new TsContext());
|
|
skyscraperContext.InitalizeFilterChain();
|
|
skyscraperContext.IngestFromStream(m3U8Stream);
|
|
}
|
|
|
|
if (args[0].Equals("aactest"))
|
|
{
|
|
new AacTestProgram().Run();
|
|
return;
|
|
}
|
|
if (args[0].ToLowerInvariant().Equals("cscan"))
|
|
{
|
|
HandleCrazyScanToTestingSystem(args[1]);
|
|
return;
|
|
}
|
|
if (args[0].ToLowerInvariant().Equals("cscan-live"))
|
|
{
|
|
HandleCrazyScanToLiveSystem(args[1]);
|
|
return;
|
|
}
|
|
if (args[0].ToLowerInvariant().Equals("cscan-live-notimeout"))
|
|
{
|
|
HandleCrazyScanToLiveSystem(args[1], false);
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("udpin"))
|
|
{
|
|
HandleUdpTesting();
|
|
return;
|
|
}
|
|
if (args[0].ToLowerInvariant().Equals("udp-agent"))
|
|
{
|
|
HandleUdpLive();
|
|
return;
|
|
}
|
|
|
|
if (args[0].Equals("abertest"))
|
|
{
|
|
FileInfo fi = new FileInfo(args[1]);
|
|
if (!fi.Exists)
|
|
{
|
|
Console.WriteLine("{0} not found", fi.FullName);
|
|
return;
|
|
}
|
|
AbertisDemoProgram abertisDemo = new AbertisDemoProgram(fi);
|
|
abertisDemo.Run();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("t2mitest"))
|
|
{
|
|
new TestApp(args[1]).Run();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("ioctltest"))
|
|
{
|
|
IoctlTest();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("m2tstots"))
|
|
{
|
|
FileInfo infile = new FileInfo(args[1]);
|
|
FileInfo outfile = new FileInfo(args[2]);
|
|
new M2TsToTs(infile,outfile).Run();
|
|
return;
|
|
}
|
|
|
|
if (Directory.Exists(args[0]))
|
|
{
|
|
DirectoryInfo doThisDir = new DirectoryInfo(args[0]);
|
|
ProcessDirectory(doThisDir);
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("proxytest"))
|
|
{
|
|
TcpTsProxy tcpTsProxy = new TcpTsProxy();
|
|
Thread.Sleep(5000);
|
|
tcpTsProxy.Dispose();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("importtest"))
|
|
{
|
|
DirectoryInfo doThisDir = new DirectoryInfo(args[1]);
|
|
IScraperStroage imss = new InMemoryScraperStorage();
|
|
TsFileCollectionImporter importer = new TsFileCollectionImporter(imss, doThisDir);
|
|
importer.Run();
|
|
return;
|
|
}
|
|
|
|
|
|
//fsimport "D:\Skyscraper" "E:\\"
|
|
if (args[0].ToLowerInvariant().Equals("fsimport"))
|
|
{
|
|
DirectoryInfo srcDir = new DirectoryInfo(args[1]);
|
|
DirectoryInfo tgtDir = new DirectoryInfo(args[2]);
|
|
IScraperStroage fss = new FilesystemScraperStorage(tgtDir);
|
|
TsFileCollectionImporter importer = new TsFileCollectionImporter(fss, srcDir);
|
|
importer.Run();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("webservertest"))
|
|
{
|
|
SkyscraperWebserver webserverTest = SkyscraperWebserver.GetInstance();
|
|
webserverTest.Start();
|
|
while (webserverTest.IsListening)
|
|
{
|
|
Thread.Sleep(1000);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("gpstest"))
|
|
{
|
|
GpsManager.GpsTest();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("mk-cable-csv"))
|
|
{
|
|
new CableFrequencyListGenerator().Run();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("what-can-i-receive"))
|
|
{
|
|
WhatCanIReceive.StandaloneProgram();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("make-dummy-ts"))
|
|
{
|
|
DummyTsGenerator dummyTsGenerator = new DummyTsGenerator();
|
|
dummyTsGenerator.Run();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("merge-bl-jobs"))
|
|
{
|
|
MergeDbBlindscanJobs.RunAsMain();
|
|
return;
|
|
}
|
|
|
|
if (args[0].ToLowerInvariant().Equals("file-live"))
|
|
{
|
|
Program.HandleFileToLiveSystem(args[1]);
|
|
return;
|
|
}
|
|
}
|
|
|
|
Passing passing = new Passing();
|
|
if (!passing.Boot())
|
|
{
|
|
Environment.Exit(1);
|
|
return;
|
|
}
|
|
passing.Run();
|
|
}
|
|
|
|
private static void StreamReaderTest(IStreamReader streamReader)
|
|
{
|
|
List<StreamReaderScanController.StreamReaderTuner> streamReaderTuners = StreamReaderScanController.GetTuners(streamReader);
|
|
if (streamReaderTuners.Count == 0)
|
|
{
|
|
Console.WriteLine("No tuners, lmao.");
|
|
return;
|
|
}
|
|
|
|
//FileInfo fi = new FileInfo("blindscan.json");
|
|
StreamReaderScanController srsc = new StreamReaderScanController(streamReader, streamReaderTuners[0]);
|
|
//srsc.SetDefaultDvbCParameters();
|
|
srsc.SetDefaultKuBandParameters();
|
|
srsc.SetParameter(StreamReaderScanController.StreamReaderParameter.ScanDiseqcType, 2);
|
|
srsc.SetParameter(StreamReaderScanController.StreamReaderParameter.DiseqcSwitchPosition, 1);
|
|
srsc.RunBlindscan();
|
|
srsc.Dispose();
|
|
return;
|
|
}
|
|
|
|
private static void ProcessDirectory(DirectoryInfo di)
|
|
{
|
|
IScraperStroage scraperStroage = new InMemoryScraperStorage();
|
|
|
|
//DirectoryInfo di = new DirectoryInfo(@"E:\Skyscraper\Astra 19.2");
|
|
FileInfo[] fileInfos = di.GetFiles("*.ts");
|
|
foreach (FileInfo fileInfo in fileInfos)
|
|
{
|
|
Console.WriteLine(new string('_', Console.WindowWidth - 1));
|
|
Console.WriteLine("Processing: {0}", fileInfo.Name);
|
|
SkyscraperContext skyscraper = new SkyscraperContext(new TsContext(), scraperStroage);
|
|
//StreamTypeAutodetectionTest streamTypeAutodetectionTest = new StreamTypeAutodetectionTest();
|
|
FileStream fileStream = fileInfo.OpenRead();
|
|
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
stopwatch.Start();
|
|
skyscraper.IngestFromStream(fileStream);
|
|
//streamTypeAutodetectionTest.IngestFromStream(fileStream);
|
|
stopwatch.Stop();
|
|
|
|
Console.WriteLine("Time to process: " + stopwatch.Elapsed.TotalSeconds);
|
|
|
|
Console.WriteLine("File was: {0}", fileInfo.Name);
|
|
PrintPidStatistics(skyscraper);
|
|
}
|
|
}
|
|
|
|
private static void PrintPidStatistics(SkyscraperContext skyscraper)
|
|
{
|
|
Console.WriteLine("Unattached PIDs:");
|
|
ulong[] pidStatistics = skyscraper.DvbContext.GetPidStatistics();
|
|
if (pidStatistics == null)
|
|
return;
|
|
for (int i = 0; i < pidStatistics.Length; i++)
|
|
{
|
|
if (pidStatistics[i] != 0)
|
|
{
|
|
if (!skyscraper.DvbContext.IsPidProcessorPresent(i))
|
|
{
|
|
Console.WriteLine("{0:X4}", i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void HandleUdpTesting()
|
|
{
|
|
HandleUdpInput(new InMemoryScraperStorage());
|
|
}
|
|
|
|
private static void HandleUdpLive()
|
|
{
|
|
ScraperStorageFactoryConnectionManager connectionManager = ScraperStorageFactoryConnectionManager.GetInstance();
|
|
IScraperStorageFactory factory = connectionManager.AutoGetDefaultFactory();
|
|
IScraperStroage scraperStorage = factory.CreateScraperStroage();
|
|
HandleUdpInput(scraperStorage);
|
|
}
|
|
|
|
private static void HandleUdpInput(IScraperStroage scraperStorage)
|
|
{
|
|
NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
|
|
foreach (NetworkInterface networkInterface in networkInterfaces)
|
|
{
|
|
IPInterfaceProperties interfaceProperties = networkInterface.GetIPProperties();
|
|
foreach (UnicastIPAddressInformation unicastAddress in interfaceProperties.UnicastAddresses)
|
|
{
|
|
Console.WriteLine("Listening on: {0}", unicastAddress.Address.ToString());
|
|
}
|
|
}
|
|
|
|
//tsp -v --control-port 9001 -I dvb --delivery-system DVB-S2 --frequency 11421000000 --symbol-rate 22000000 --polarity horizontal -O ip 127.0.0.1:9001
|
|
//SkyscraperWebserver.GetInstance().Start();
|
|
//scraperStorage = new FilesystemScraperStorage(new DirectoryInfo("C:\\scraped_data"));
|
|
|
|
SkyscraperContext skyscraper = null;
|
|
|
|
UdpClient udpServer = new UdpClient(new IPEndPoint(IPAddress.Any, 9003));
|
|
IPEndPoint remote = null;
|
|
IPEndPoint oldRemote = null;
|
|
int numPackets;
|
|
byte[] singlePacket = new byte[188];
|
|
while (true)
|
|
{
|
|
byte[] buffer = udpServer.Receive(ref remote);
|
|
if (!remote.Equals(oldRemote))
|
|
{
|
|
oldRemote = remote;
|
|
skyscraper = new SkyscraperContext(new TsContext(), scraperStorage);
|
|
skyscraper.InitalizeFilterChain();
|
|
skyscraper.EnableTimeout = true;
|
|
logger.InfoFormat("Got zapped by {0}", remote);
|
|
}
|
|
|
|
numPackets = buffer.Length / 188;
|
|
for (int i = 0; i < numPackets; i++)
|
|
{
|
|
Array.Copy(buffer, i * 188, singlePacket, 0, 188);
|
|
skyscraper.IngestSinglePacket(singlePacket);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void HandleCrazyScanToTestingSystem(string url)
|
|
{
|
|
|
|
IScraperStroage scraperStorage = new InMemoryScraperStorage();
|
|
HandleCrazyScan(url, scraperStorage, true);
|
|
}
|
|
|
|
private static void HandleFileToLiveSystem(string filename)
|
|
{
|
|
ScraperStorageFactoryConnectionManager connectionManager = ScraperStorageFactoryConnectionManager.GetInstance();
|
|
IScraperStorageFactory factory = connectionManager.AutoGetDefaultFactory();
|
|
IScraperStroage scraperStorage = factory.CreateScraperStroage();
|
|
FileInfo fi = new FileInfo(filename);
|
|
if (!fi.Exists)
|
|
{
|
|
Console.WriteLine("{0} not found.", fi.FullName);
|
|
return;
|
|
}
|
|
|
|
SkyscraperContext skyscraper = new SkyscraperContext(new TsContext(), scraperStorage);
|
|
skyscraper.InitalizeFilterChain();
|
|
skyscraper.EnableTimeout = false;
|
|
skyscraper.TcpProxyEnabled = false;
|
|
FileStream fileStream = fi.OpenRead();
|
|
skyscraper.IngestFromStream(fileStream);
|
|
fileStream.Close();
|
|
fileStream.Dispose();
|
|
skyscraper.Dispose();
|
|
}
|
|
|
|
|
|
|
|
private static void HandleCrazyScanToLiveSystem(string url, bool withTimeout = true)
|
|
{
|
|
ScraperStorageFactoryConnectionManager connectionManager = ScraperStorageFactoryConnectionManager.GetInstance();
|
|
IScraperStorageFactory factory = connectionManager.AutoGetDefaultFactory();
|
|
IScraperStroage storage = factory.CreateScraperStroage();
|
|
storage.Ping();
|
|
HandleCrazyScan(url, storage, withTimeout);
|
|
}
|
|
|
|
private static void HandleCrazyScan(string url, IScraperStroage scraperStorage, bool timeout)
|
|
{
|
|
if (!url.StartsWith("tcp://"))
|
|
{
|
|
logger.Fatal("Use TCP, please.");
|
|
return;
|
|
}
|
|
|
|
if (url.EndsWith("/"))
|
|
{
|
|
logger.Fatal("Don't use that trailing slash, please.");
|
|
return;
|
|
}
|
|
|
|
url = url.Substring(6);
|
|
string[] strings = url.Split(':');
|
|
string hostname = strings[0];
|
|
int port = Int32.Parse(strings[1]);
|
|
|
|
TcpClient tcpClient = new TcpClient(hostname, port);
|
|
|
|
SkyscraperContext skyscraper = new SkyscraperContext(new TsContext(), scraperStorage);
|
|
skyscraper.InitalizeFilterChain(new SkipFilter(1024));
|
|
//skyscraper.EnableTimeout = timeout;
|
|
//skyscraper.TimeoutSeconds = 10;
|
|
skyscraper.TcpProxyEnabled = true;
|
|
skyscraper.IngestFromStream(new BufferedStream(tcpClient.GetStream(), 96256 * 2));
|
|
}
|
|
|
|
private static void HandleSingleFile(FileInfo fi)
|
|
{
|
|
//Environment.CurrentDirectory = fi.Directory.FullName;
|
|
TsContext tsContext = new TsContext();
|
|
IScraperStroage scraperStorage = new InMemoryScraperStorage();
|
|
SkyscraperContext skyscraper = new SkyscraperContext(tsContext, scraperStorage);
|
|
skyscraper.InitalizeFilterChain();
|
|
FileStream fileStream = fi.OpenRead();
|
|
skyscraper.IngestFromStream(fileStream);
|
|
skyscraper.Dispose();
|
|
fileStream.Close();
|
|
|
|
Console.WriteLine("");
|
|
Console.WriteLine("Current Network ID: {0}", skyscraper.CurrentNetworkId);
|
|
Console.WriteLine("Current Transport Stream ID: {0}", skyscraper.CurrentTransportStreamId);
|
|
if (tsContext.PcrMonitor != null)
|
|
{
|
|
Console.WriteLine("Processing Performance: {0}", tsContext.PcrMonitor.Performance);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("No PCR detected.");
|
|
}
|
|
Console.WriteLine("DNS Records found: {0}", scraperStorage.DnsCountA());
|
|
Console.WriteLine("");
|
|
|
|
Console.WriteLine(new string('-', Console.WindowWidth));
|
|
Console.WriteLine("<any key to close>");
|
|
Console.ReadKey(true);
|
|
}
|
|
|
|
private static void IoctlTest()
|
|
{
|
|
/*
|
|
int dvbSatSearchLnb = LibDvbV5.DvbSatSearchLnb("EXTENDED");
|
|
LibDvbV5SatLnb lnb = new LibDvbV5SatLnb(dvbSatSearchLnb);
|
|
|
|
LibDvbV5Device device = new LibDvbV5Device();
|
|
device.SetLog(8, null);
|
|
device.Find();
|
|
|
|
LibDvbV5DeviceList findDeviceByDeliverySystem = device.FindDeviceByDeliverySystem(LibDvbV5FrontendDeliverySystem.SYS_DVBC_ANNEX_A);
|
|
if (findDeviceByDeliverySystem == null)
|
|
return;
|
|
|
|
LibDvbV5DeviceList demuxerName = device.GetSisterDevice(findDeviceByDeliverySystem, DvbDeviceType.Demux);
|
|
LibDvbV5DeviceList dvrName = device.GetSisterDevice(findDeviceByDeliverySystem, DvbDeviceType.Dvr);
|
|
|
|
LibDvb5FrontendParameters frontend = findDeviceByDeliverySystem.ToFrontendParameters();
|
|
frontend.SetDeliverySystem(LibDvbV5FrontendDeliverySystem.SYS_DVBC_ANNEX_A);
|
|
frontend.StoreParameter(17, (uint)LibDvbV5FrontendDeliverySystem.SYS_DVBC_ANNEX_A);
|
|
frontend.StoreParameter(3, 610000000); //freq
|
|
frontend.StoreParameter(8, 6900000); //symbol rate
|
|
frontend.SetParameters();
|
|
Thread.Sleep(400);
|
|
frontend.GetStatistics();
|
|
Thread.Sleep(400);
|
|
uint retrieveStats = frontend.RetrieveStats(512);
|
|
if ((retrieveStats & 0x10) != 0)
|
|
{
|
|
Console.WriteLine("got lock!");
|
|
LibDvbV5OpenDescriptor dvrFd = device.DeviceOpen(dvrName);
|
|
if (dvrFd == null)
|
|
throw new IOException("open failed");
|
|
dvrFd.SetBufferSize(1024 * 1024);
|
|
|
|
LibDvbV5OpenDescriptor demuxFd = device.DeviceOpen(demuxerName);
|
|
if (demuxFd == null)
|
|
throw new IOException("open failed");
|
|
|
|
demuxFd.DemuxSetPesFilter(0x2000, DemuxerPesType.DMX_PES_OTHER);
|
|
|
|
FileStream fileStream = File.OpenWrite(String.Format("{0}.ts", DateTime.Now.Ticks));
|
|
byte[] packBuffer = new byte[188];
|
|
int readLen = 0;
|
|
for (int i = 0; i < 9001; i++)
|
|
{
|
|
readLen = dvrFd.Read(packBuffer, 188);
|
|
if (readLen > 0)
|
|
{
|
|
fileStream.Write(packBuffer, 0, 188);
|
|
}
|
|
}
|
|
|
|
fileStream.Flush(true);
|
|
fileStream.Close();
|
|
demuxFd.Dispose();
|
|
dvrFd.Dispose();
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("no lock :(");
|
|
}
|
|
frontend.Dispose();
|
|
device.Dispose();
|
|
Thread.Sleep(1000);
|
|
return;*/
|
|
/*FileInfo fi = new FileInfo("/dev/video0");
|
|
SafeUnixHandle safeUnixHandle = UnsafeLibCNativeMethodsWrappers.OpenDevice(fi);
|
|
UnsafeLibCNativeMethodsWrappers.GetCapability(safeUnixHandle);
|
|
UnsafeLibCNativeMethodsWrappers.Close(safeUnixHandle);*/
|
|
|
|
//LocalStreamReader streamReader = LocalStreamReader.GetInstance();
|
|
IStreamReader streamReader = new NullStreamReader();
|
|
|
|
bool checkForDvb = streamReader.CheckForDVB();
|
|
if (checkForDvb)
|
|
{
|
|
streamReader.CheckForDVBEx((x, y) => { Console.WriteLine("{0}, {1}", x, y); });
|
|
if (streamReader.StartDvbEx(0))
|
|
{
|
|
|
|
STD_TYPE ttype = default;
|
|
bool result = streamReader.GetTunerType(ref ttype);
|
|
if (!result)
|
|
Console.WriteLine("oh no");
|
|
|
|
Caps caps = streamReader.GetCaps();
|
|
|
|
BlScanCallback scanCallback =
|
|
(ref SearchResult searchResult) =>
|
|
{
|
|
Console.WriteLine("{0}/{1}/{2}",searchResult.Freq,searchResult.Pol,searchResult.SR);
|
|
};
|
|
|
|
/*UnsafeStreamReaderMethods.AirScanCallback airScanCallback =
|
|
(ref UnsafeStreamReaderMethods.SearchResult2 searchResult2) =>
|
|
{
|
|
Console.WriteLine(searchResult2.Freq);
|
|
};*/
|
|
AirScanCallback altTest = (ref SearchResult2 searchResult) =>
|
|
{
|
|
Console.WriteLine(searchResult.Freq);
|
|
};
|
|
|
|
//int tpNum = 0;
|
|
//result = UnsafeStreamReaderMethods.BLScanEx(10744000, 8000, 1, 9750000, 10600000, 11700000, 1, UnsafeStreamReaderMethods.STD_TYPE.STD_DVBS2, ref sr1);
|
|
//result = UnsafeStreamReaderMethods.BLScan(10744000, 8000, 0, 9750000, 10600000, 11700000, 1000, ref sr1);
|
|
/*result = UnsafeStreamReaderMethods.SetChannelExEx(10744000, 22000000, 0,
|
|
UnsafeStreamReaderMethods.VITERBIRATE_TYPE.VR_5_6, 9750000, 10600000, 11700000,
|
|
UnsafeStreamReaderMethods.MOD_TYPE.MOD_QPSK, 0, 0,
|
|
UnsafeStreamReaderMethods.ROLLOFF_TYPE.ROLLOFF_AUTO);*/
|
|
/*
|
|
result = UnsafeStreamReaderMethods.SendDiSEqC(2,
|
|
UnsafeStreamReaderMethods.DiSEqC_Opcode.DISEQC_HIGH_NIBBLE |
|
|
UnsafeStreamReaderMethods.DiSEqC_Opcode.DISEQC_LOW_BAND |
|
|
UnsafeStreamReaderMethods.DiSEqC_Opcode.DISEQC_HORIZONTAL |
|
|
UnsafeStreamReaderMethods.DiSEqC_Opcode.DISEQC_POSITION_B |
|
|
UnsafeStreamReaderMethods.DiSEqC_Opcode.DISEQC_OPTION_A);
|
|
result = UnsafeStreamReaderMethods.SetChannel(10775000, 29900000, 0,
|
|
UnsafeStreamReaderMethods.VITERBIRATE_TYPE.VR_3_5, 9750000, 10600000, 11700000);
|
|
|
|
|
|
for (int i = 0; i < 100; i++)
|
|
{
|
|
Thread.Sleep(1000);
|
|
}
|
|
*/
|
|
|
|
|
|
SearchResult2 sr1 = default;
|
|
SearchResult2 sr2 = default;
|
|
int tpNum = default;
|
|
IntPtr allocHGlobal = Marshal.AllocHGlobal(1024);
|
|
result = streamReader.AirScan(100000, 800000, 3000, 8000, (int)STD_TYPE.STD_DVBC, allocHGlobal, ref tpNum, altTest);
|
|
SearchResult2 ptrToStructure = (SearchResult2)Marshal.PtrToStructure(allocHGlobal, typeof(SearchResult2));
|
|
Marshal.FreeHGlobal(allocHGlobal);
|
|
Console.WriteLine(tpNum);
|
|
|
|
/*
|
|
byte[] buffer = new byte[1024];
|
|
|
|
int offset = 0;
|
|
FileStream fileStream = File.OpenWrite("tbs5580.bin");
|
|
result = true;
|
|
while (result)
|
|
{
|
|
result = UnsafeStreamReaderMethods.GetEEPROM(buffer, offset, 8);
|
|
if (result)
|
|
{
|
|
fileStream.Write(buffer, 0, 8);
|
|
offset += 8;
|
|
}
|
|
}
|
|
|
|
fileStream.Flush(true);
|
|
fileStream.Close();
|
|
*/
|
|
|
|
/*
|
|
*
|
|
double snr = default;
|
|
for (uint i = 100; i < 200; i++)
|
|
{
|
|
result = UnsafeStreamReaderMethods.RFScan2(i * 1000, UnsafeStreamReaderMethods.STD_TYPE.STD_DVBC, ref snr);
|
|
if (result)
|
|
Console.WriteLine("{0} -> {1}", i, snr);
|
|
}
|
|
|
|
*/
|
|
/*
|
|
UnsafeStreamReaderMethods.SearchResult sr1 = default;
|
|
UnsafeStreamReaderMethods.SearchResult sr2 = default;
|
|
int tpNum = default;
|
|
result = UnsafeStreamReaderMethods.SetChannel(10744000, 22000000, 0, 0, 9750000, 10600000, 11700000);
|
|
ulong numPackets = 0;
|
|
IntPtr filterPtr = default;
|
|
byte[] buffer = new byte[188];
|
|
FileStream fs = File.OpenWrite("test.ts");
|
|
result = UnsafeStreamReaderMethods.SetFilter(8192, ((data, length) =>
|
|
{
|
|
//Console.WriteLine("Packet {0}", numPackets++);
|
|
Marshal.Copy(data, buffer, 0, length);
|
|
fs.Write(buffer, 0, 188);
|
|
}), 0x02, 1, ref filterPtr);
|
|
|
|
sbyte[] iq = new sbyte[200];
|
|
for (int i = 0; i < 150; i++)
|
|
{
|
|
Thread.Sleep(100);
|
|
UnsafeStreamReaderMethods.IQScan(0, iq, 100);
|
|
Console.WriteLine("{0},{1} - {2},{3} - {4},{5} - {6},{7}", iq[0], iq[1], iq[2], iq[3], iq[4], iq[5], iq[6], iq[7]);
|
|
}
|
|
result = UnsafeStreamReaderMethods.DelFilter(filterPtr);
|
|
fs.Flush(true);
|
|
fs.Close();
|
|
*/
|
|
//result = UnsafeStreamReaderMethods.BLScan(11068, 8000, 1, 975000, 10600000, 11700000, 1, ref sr);
|
|
|
|
/*
|
|
for (int i = 10700; i < 12750; i += 3)
|
|
{
|
|
result = UnsafeStreamReaderMethods.BLScan(i, 0, 1, 975000, 10600000, 11700000, 1, ref sr1);
|
|
if (sr1.SR != 0)
|
|
{
|
|
Console.Write("\r\n{0}/{1}/{2}", i, sr1.Pol, sr1.SR);
|
|
}
|
|
else
|
|
{
|
|
Console.Write(".");
|
|
}
|
|
result = UnsafeStreamReaderMethods.BLScan(i, 0, 0, 975000, 10600000, 11700000, 1, ref sr1);
|
|
if (sr1.SR != 0)
|
|
{
|
|
Console.Write("\r\n{0}/{1}/{2}", i, sr1.Pol, sr1.SR);
|
|
}
|
|
else
|
|
{
|
|
Console.Write(".");
|
|
}
|
|
}*/
|
|
|
|
//result = UnsafeStreamReaderMethods.BLScan2(10700, 12750, 0, 975000, 10600000, 11700000, ref sr1, ref tpNum, scanCallback);
|
|
|
|
/*
|
|
byte[] macBuffer = new byte[6];
|
|
result = UnsafeStreamReaderMethods.GetMAC(macBuffer);
|
|
*/
|
|
/*
|
|
double m = default;
|
|
for (int i = 10700; i < 12750; i += 1)
|
|
{
|
|
result = UnsafeStreamReaderMethods.RFScan(i, 0, 975000, 10600000, 11700000, out m);
|
|
Console.WriteLine("{2} {0} -> {1}", i, m, result);
|
|
}
|
|
*/
|
|
|
|
|
|
/*
|
|
result = UnsafeStreamReaderMethods.SetChannel(10744000, 22000000, 0, 0, 9750000, 10600000, 11700000);
|
|
|
|
if (File.Exists("test.ts"))
|
|
File.Delete("test.ts");
|
|
|
|
FileStream fileStream = File.OpenWrite("test.ts");
|
|
IntPtr filterPtr = IntPtr.Zero;
|
|
byte[] packet = new byte[188];
|
|
UnsafeStreamReaderMethods.StdcallDvbCallback callback = (bytes, k) =>
|
|
{
|
|
Marshal.Copy(bytes, packet, 0, k);
|
|
fileStream.Write(packet, 0, 188);
|
|
};
|
|
result = UnsafeStreamReaderMethods.SetFilter(8192, callback, 0x02, 1, ref filterPtr);
|
|
|
|
if (!result)
|
|
throw new NotImplementedException("no filter");
|
|
|
|
IntPtr rcPtr = IntPtr.Zero;
|
|
result = UnsafeStreamReaderMethods.SetRemoteControl(0, -1, (bytes, k) =>
|
|
{
|
|
Console.WriteLine(k);
|
|
},
|
|
ref rcPtr);
|
|
|
|
result = UnsafeStreamReaderMethods.DelFilter(rcPtr);
|
|
result = UnsafeStreamReaderMethods.DelFilter(filterPtr);
|
|
*/
|
|
|
|
/*
|
|
if (!UnsafeStreamReaderMethods.StopDVB())
|
|
Console.WriteLine("wtf");
|
|
*/
|
|
/*
|
|
fileStream.Flush(true);
|
|
fileStream.Close();
|
|
*/
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|