public CaPmtSection(PmtSection pmtSource, int pmtPid, int tsid, int nid, byte ca, byte dmx, byte adapter, ListManagement type)
{
_Source = pmtSource;
_pmtPid = pmtPid;
_Ca = ca;
_Dmx = dmx;
_Adapter = adapter;
_Type = type;
_TsId = tsid;
_Nid = nid;
}
private void Stop(bool fromApi)
{
_CurrentPmt = null;
CurrentPid = -1;
CurrentNId = -1;
CurrentTsId = -1;
DvbApiDemuxIndex = -1;
LastEcmInfo = null;
if (!fromApi)
{
ChannelUpdated?.Invoke(this, false);
}
else
{
_IcEp.SendCommand(InterComCommand.Stop);
}
}
/// <summary>
/// Sendet gegebene Section durch die Pipe.
/// </summary>
/// <param name="sec"></param>
private void IcPmt(PmtSection pmt)
{
if (_AdapterIndex < 0)
{
return;
}
using (MemoryStream ms = new MemoryStream())
using (BinaryWriter w = new BinaryWriter(ms))
{
w.Write(_NetworkId);
w.Write(_TransportStreamId);
w.Write(_PmtPid);
w.Flush();
pmt.WriteToStream(ms);
_IcEp.SendCommand(InterComCommand.Pmt, ms.ToArray());
}
}
/// <summary>
/// Bearbeitet TS-Packets für PAT, CAT, SDT, PMT, ECM und EMM
/// </summary>
/// <param name="tsPacket"></param>
private void ProcessTsPacket(IntPtr tsPacket, int pid)
{
if (pid == 0x0000) // PAT
{
if (_TmpPat != null && _TmpPat.AddPacket(tsPacket))
{
_Pat = _TmpPat;
_TmpPat = null;
int pmtPid = _Pat.GetPmtPidBySid(_ServiceId);
if (_TransportStreamId != -1 && _TransportStreamId != 0xffff && _Pat.TransportStreamId != _TransportStreamId)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterWrongPat, _Pat.TransportStreamId, _TransportStreamId);
}
if (pmtPid == -1)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterServiceNotFound, _Pat.TransportStreamId, _ServiceId);
_TmpPat = new PatSection();
}
else if (_PmtPid != pmtPid) // PmtPid beim Tune Falsch
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterRetuneOnPat);
Tune(_ServiceId, pmtPid, _TransportStreamId, _NetworkId); // Retune mit richtigen Daten.
}
else
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterPatDone);
DelPid(0);
}
}
}
else if (pid == 0x0011) // SDT
{
if (_TmpSdt != null && _TmpSdt.AddPacket(tsPacket))
{
_Sdt = _TmpSdt;
_TmpSdt = null;
if (_TransportStreamId != -1 && _TransportStreamId != 0xffff)
{
if (_Sdt.TransportStreamId != _TransportStreamId)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterWrongSdt, _Sdt.TransportStreamId, _TransportStreamId);
_TmpSdt = new SdtSection(true);
}
else if (_NetworkId != _Sdt.OriginalNetworkId)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterRetuneOnSdt);
Tune(_ServiceId, _PmtPid, _TransportStreamId, _Sdt.OriginalNetworkId); // Retune mit richtigen Daten.
}
else
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterSdtDone);
DelPid(0x0011);
}
}
else
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterSdtDoneNoTsId);
}
}
}
else if (pid == _PmtPid)
{
if (_TmpPmt != null && _TmpPmt.AddPacket(tsPacket))
{
if (_TmpPmt.ServiceId != _ServiceId)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterWrongPmt, _TmpPmt.ServiceId);
if (_Pmt != null)
{
LogProvider.Add(DebugLevel.Warning, cLogSection, Message.AdapterStopPmtTracking);
DelPid(_PmtPid);
_TmpPmt = null;
}
}
else
{
if (_AdapterIndex != -1 && (_Pmt == null || (_Pmt != null && _Pmt.Version != _TmpPmt.Version))) // dann pipe verbunden.
{
IcPmt(_TmpPmt);
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterPmtDone, _PmtPid, _ServiceId, _TmpPmt.Version);
if (_Pmt != null)
{
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterPmtVer, _Pmt.Version);
}
}
_Pmt = _TmpPmt;
_TmpPmt = new PmtSection(_PmtPid);
}
}
}
// Filter durchlaufen, und checken ob hier was bei ist, was an oscam geht.
lock (_Filters)
{
foreach (DemuxFilter f in _Filters)
{
if (f.Pid == pid && f.AddPacket(tsPacket))
{
byte[][] filtered = f.GetFilteredSections();
foreach (byte[] data in filtered)
{
IcFilterData(f.Number, data, data.Length);
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterDataFiltered, f.Number, f.Pid);
LogProvider.Add(DebugLevel.Info | DebugLevel.HexDump, cLogSection, Message.Empty, data, 0, data.Length < 18 ? data.Length : 18);
}
f.Reset();
}
}
}
}
public void Tune(int sid, int pmt, int tsId, int nId)
{
if (sid == -1)
{
if (_ServiceId == -1) // dann bereits untuned.
{
return;
}
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterEvUntune);
lock (_Filters)
_Filters.Clear();
DelAllPids();
IcStop();
_Pmt = null;
_Pat = null;
_Sdt = null;
_TmpPmt = null;
_TmpPat = null;
_TmpSdt = null;
try
{
if (_DumpFileStream != null)
{
lock (_DumpFileStream)
{
_DumpFileStream.Close();
_DumpFileStream = null;
}
}
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.AdapterDumpStopFailed, ex);
}
//Pids zurücksetzen:
ClearDescramblers();
}
else
{
if (_ServiceId != -1 || _PmtPid != -1) // dann fehlte wohl untune/disable tuner
{
Tune(-1, -1, -1, -1); // reset.
}
LogProvider.Add(DebugLevel.Info, cLogSection, Message.AdapterEvTune, sid, pmt, tsId, nId);
try
{
if (_DumpStream)
{
string filename = DateTime.Now.ToString("yyyyMMddHHmmss");
filename = $"tsdump-{_AdapterIndex}-{filename}-{sid}-{tsId}.ts";
filename = Path.Combine(Globals.HomeDirectory.FullName, filename);
_DumpFileStream = new FileStream(filename, FileMode.Create);
}
}
catch (Exception ex)
{
LogProvider.Exception(cLogSection, Message.AdapterDumpStartFailed, ex);
}
_TmpPat = new PatSection();
AddPid(0x0000); // PAT holen um PMT Pid zu bestimmen über sid falls PMT fehlt oder falsch.
if (pmt > 0)
{
_TmpPmt = new PmtSection(pmt);
AddPid(pmt);
}
if (nId < 0)
{
_TmpSdt = new SdtSection(true);
AddPid(0x0011);
}
}
_ServiceId = sid;
_PmtPid = pmt;
_TransportStreamId = tsId;
_NetworkId = nId;
}
private void CommandReceived(InterComEndPoint sender, InterComCommand cmd, byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
using (BinaryReader rdr = new BinaryReader(ms))
{
switch (cmd)
{
case InterComCommand.Stop:
Stop(false);
break;
case InterComCommand.Pmt:
// 1 int pmt pid, 1 int sid;
bool update = false;
bool add = CurrentSid == -1;
int tmp = rdr.ReadInt32(); // 4 byte nid
if (tmp != CurrentNId)
{
update = true;
CurrentNId = tmp;
}
tmp = rdr.ReadInt32(); // 4 byte tsid
if (tmp != CurrentTsId)
{
update = true;
CurrentTsId = tmp;
}
tmp = rdr.ReadInt32(); // 4 byte Pid
if (tmp != CurrentPid)
{
update = true;
CurrentPid = tmp;
}
PmtSection pmt = new PmtSection(data, (int)rdr.BaseStream.Position, CurrentPid);
if (_CurrentPmt == null || _CurrentPmt.Version != pmt.Version)
{
update = true;
_CurrentPmt = pmt;
}
if (update)
{
ChannelUpdated?.Invoke(this, add);
}
break;
case InterComCommand.FilterData:
int fltId = rdr.ReadInt32();
byte[] fData = rdr.ReadBytes(data.Length - sizeof(int));
FilterData?.Invoke(this, fltId, fData);
break;
default:
// unbekannter befehl. oder anderswo abgefangen Sollte nicht vorkommen
// Da aber bereits alle Bytes gelesen, ignorieren und weiter im Programm.
break;
}
}
}
