private Collection <Mpeg2Section> getNextSection()
{
if (!initialized)
{
initialize();
}
if (currentOffset >= maxOffset)
{
getMaxOffset();
return(null);
}
byte[] buffer = new byte[188];
Marshal.Copy(currentPointer, buffer, 0, 188);
currentPointer = new IntPtr(currentPointer.ToInt64() + 188);
currentOffset += 188;
if (RunParameters.Instance.TraceIDs.Contains("TRANSPORTPACKETS"))
{
Logger.Instance.Dump("Transport Packet", buffer, buffer.Length);
}
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
}
catch (ArgumentOutOfRangeException)
{
Logger.Instance.Write("Transport packet parsing failed at current offset " + currentOffset +
" max offset: " + maxOffset);
return(null);
}
if (transportPacket.IsNullPacket || transportPacket.ErrorIndicator)
{
return(null);
}
/*Logger.Instance.Write("Processing PID 0x" + transportPacket.PID.ToString("X") + " from offset " + currentOffset);*/
PidHandler pidHandler = findPidHandler(transportPacket.PID);
pidHandler.Process(buffer, transportPacket);
/*Logger.Instance.Write("PID handler 0x" + pidHandler.Pid.ToString("X") + " has created " + pidHandler.Sections.Count + " sections");*/
return(pidHandler.Sections);
}
private SIPacket getPacket(bool needPayloadStart)
{
if (eof)
{
return(null);
}
SIPacket siPacket = null;
bool done = false;
while (!done)
{
if (memoryHandle == 0)
{
bool reply = getMappedMemory();
if (!reply)
{
eof = true;
return(null);
}
}
if (currentOffset > maxOffset)
{
return(null);
}
byte[] buffer = new byte[188];
for (int index = 0; index < 188; index++)
{
buffer[index] = this.buffer[currentPointer + index];
}
currentPointer += 188;
currentOffset += 188;
TransportPacket transportPacket = new TransportPacket();
transportPacket.Process(buffer);
if (transportPacket.PID == pid)
{
Logger.Instance.Dump("File Packet", buffer, buffer.Length);
if (!transportPacket.ErrorIndicator && !transportPacket.IsNullPacket)
{
if (needPayloadStart)
{
if (transportPacket.StartIndicator)
{
done = true;
}
}
else
{
done = true;
}
if (done)
{
siPacket = new SIPacket();
siPacket.Process(buffer, transportPacket);
}
}
}
}
return(siPacket);
}
private bool fillBuffer(FileStream fileStream)
{
if (pids == null)
{
Thread.Sleep(100);
return (false);
}
if (size + 136 + packetSize > memorySize)
{
return (false);
}
byte[] buffer = new byte[packetSize];
int readCount = getPacket(fileStream, buffer);
if (readCount < packetSize)
return (false);
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
}
catch (ArgumentOutOfRangeException)
{
Logger.Instance.Write("Sync byte error");
return (false);
}
if (RunParameters.Instance.TraceIDs.Contains("MPEG2PACKETS"))
{
if (pids[0] == -1 || pids.Contains(transportPacket.PID))
Logger.Instance.Dump("Simulation Packet for PID " + transportPacket.PID, buffer, buffer.Length);
}
if (transportPacket.ErrorIndicator)
return (false);
if (transportPacket.IsNullPacket)
return (false);
bool reply = resourceMutex.WaitOne(5000, true);
if (pids[0] == -1 || pids.Contains(transportPacket.PID))
{
Marshal.Copy(buffer, 0, offset, buffer.Length);
offset = new IntPtr(offset.ToInt64() + packetSize);
size += packetSize;
Marshal.WriteInt32(memoryBlock, size);
}
if (reply)
resourceMutex.ReleaseMutex();
return (false);
}
private SIPacket getPacket(bool needPayloadStart)
{
if (eof)
{
return(null);
}
SIPacket siPacket = null;
bool done = false;
while (!done)
{
if (fileStream == null)
{
fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
}
byte[] buffer = new byte[188];
int readCount = fileStream.Read(buffer, 0, 188);
if (readCount < 188)
{
fileStream.Close();
eof = true;
return(null);
}
blockCount++;
if (RunParameters.Instance.TraceIDs.Contains("TSFILEPACKETS"))
{
Logger.Instance.Dump("File Packet " + blockCount, buffer, buffer.Length);
}
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
if (!transportPacket.ErrorIndicator && !transportPacket.IsNullPacket)
{
if (pids == null || (pids != null && pids.Contains((short)transportPacket.PID)))
{
if (RunParameters.Instance.TraceIDs.Contains("TSPIDPACKETS"))
{
Logger.Instance.Dump("File Packet", buffer, buffer.Length);
}
if (needPayloadStart)
{
if (transportPacket.StartIndicator)
{
continuityCount = transportPacket.ContinuityCount;
done = true;
}
}
else
{
if (continuityCount == 15)
{
continuityCount = 0;
}
else
{
continuityCount++;
}
if (transportPacket.ContinuityCount == continuityCount)
{
done = true;
}
else
{
if (RunParameters.Instance.TraceIDs.Contains("CONTINUITYERRORS"))
{
Logger.Instance.Write("Continuity error: expected " + continuityCount + " got " + transportPacket.ContinuityCount);
}
needPayloadStart = true;
return(null);
}
}
if (done)
{
siPacket = new SIPacket();
siPacket.Process(buffer, transportPacket);
}
}
}
}
catch (ArgumentOutOfRangeException)
{
/*Logger.Instance.Write("Failed to parse transport packet");*/
}
}
return(siPacket);
}
private SIPacket getPacket(bool needPayloadStart)
{
if (eof)
return (null);
SIPacket siPacket = null;
bool done = false;
while (!done)
{
if (fileStream == null)
fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buffer = new byte[188];
int readCount = fileStream.Read(buffer, 0, 188);
if (readCount < 188)
{
fileStream.Close();
eof = true;
return (null);
}
blockCount++;
if (RunParameters.Instance.TraceIDs.Contains("TSFILEPACKETS"))
Logger.Instance.Dump("File Packet " + blockCount, buffer, buffer.Length);
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
if (!transportPacket.ErrorIndicator && !transportPacket.IsNullPacket)
{
if (pids == null || (pids != null && pids.Contains((short)transportPacket.PID)))
{
if (RunParameters.Instance.TraceIDs.Contains("TSPIDPACKETS"))
Logger.Instance.Dump("File Packet", buffer, buffer.Length);
if (needPayloadStart)
{
if (transportPacket.StartIndicator)
{
continuityCount = transportPacket.ContinuityCount;
done = true;
}
}
else
{
if (continuityCount == 15)
continuityCount = 0;
else
continuityCount++;
if (transportPacket.ContinuityCount == continuityCount)
done = true;
else
{
if (RunParameters.Instance.TraceIDs.Contains("CONTINUITYERRORS"))
Logger.Instance.Write("Continuity error: expected " + continuityCount + " got " + transportPacket.ContinuityCount);
needPayloadStart = true;
return (null);
}
}
if (done)
{
siPacket = new SIPacket();
siPacket.Process(buffer, transportPacket);
}
}
}
}
catch (ArgumentOutOfRangeException)
{
/*Logger.Instance.Write("Failed to parse transport packet");*/
}
}
return (siPacket);
}
private Collection<Mpeg2Section> getNextSection()
{
if (!initialized)
initialize();
if (currentOffset >= maxOffset)
{
getMaxOffset();
return (null);
}
byte[] buffer = new byte[188];
Marshal.Copy(currentPointer, buffer, 0, 188);
currentPointer = new IntPtr(currentPointer.ToInt64() + 188);
currentOffset += 188;
if (RunParameters.Instance.TraceIDs.Contains("TRANSPORTPACKETS"))
Logger.Instance.Dump("Transport Packet", buffer, buffer.Length);
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
}
catch (ArgumentOutOfRangeException)
{
Logger.Instance.Write("Transport packet parsing failed at current offset " + currentOffset +
" max offset: " + maxOffset);
return (null);
}
if (transportPacket.IsNullPacket || transportPacket.ErrorIndicator)
return (null);
/*Logger.Instance.Write("Processing PID 0x" + transportPacket.PID.ToString("X") + " from offset " + currentOffset);*/
PidHandler pidHandler = findPidHandler(transportPacket.PID);
pidHandler.Process(buffer, transportPacket);
/*Logger.Instance.Write("PID handler 0x" + pidHandler.Pid.ToString("X") + " has created " + pidHandler.Sections.Count + " sections");*/
return (pidHandler.Sections);
}
private SIPacket getPacket(bool needPayloadStart)
{
if (eof)
return (null);
SIPacket siPacket = null;
bool done = false;
while (!done)
{
if (memoryHandle == 0)
{
bool reply = getMappedMemory();
if (!reply)
{
eof = true;
return(null);
}
}
if (currentOffset > maxOffset)
return (null);
byte[] buffer = new byte[188];
for (int index = 0; index < 188; index++)
buffer[index] = this.buffer[currentPointer + index];
currentPointer += 188;
currentOffset += 188;
TransportPacket transportPacket = new TransportPacket();
transportPacket.Process(buffer);
if (transportPacket.PID == pid)
{
Logger.Instance.Dump("File Packet", buffer, buffer.Length);
if (!transportPacket.ErrorIndicator && !transportPacket.IsNullPacket)
{
if (needPayloadStart)
{
if (transportPacket.StartIndicator)
done = true;
}
else
done = true;
if (done)
{
siPacket = new SIPacket();
siPacket.Process(buffer, transportPacket);
}
}
}
}
return (siPacket);
}
private void getData(ISampleDataProvider dataProvider, AnalysisParameters analysisParameters, BackgroundWorker worker)
{
Logger.Instance.Write("Starting analysis");
analysisParameters.ScanningFrequency.CollectionType = CollectionType.MHEG5;
FrequencyScanner frequencyScanner = new FrequencyScanner(dataProvider, worker);
Collection<TVStation> stations = frequencyScanner.FindTVStations();
pidList = new Collection<PidSpec>();
dataProvider.ChangePidMapping(new int[] { -1 });
IntPtr memoryPointer = dataProvider.BufferAddress;
int currentOffset = 0;
byte[] buffer = new byte[188];
DateTime startTime = DateTime.Now;
int packetCount = 0;
int errorPackets = 0;
int nullPackets = 0;
while ((DateTime.Now - startTime).TotalSeconds < analysisParameters.DataCollectionTimeout && !worker.CancellationPending)
{
if (currentOffset >= dataProvider.BufferSpaceUsed)
{
Thread.Sleep(2000);
if (currentOffset >= dataProvider.BufferSpaceUsed)
{
Logger.Instance.Write("Analysis resetting pid after " + packetCount + " packets (errors = " + errorPackets + " null = " + nullPackets + ")");
dataProvider.ChangePidMapping(new int[] { -1 });
currentOffset = 0;
}
}
else
{
IntPtr currentPointer = new IntPtr(memoryPointer.ToInt64() + currentOffset + 136);
Marshal.Copy(currentPointer, buffer, 0, 188);
packetCount++;
/*if (dumpCount < 10000)
{
Logger.Instance.Dump("atsc " + dumpCount, buffer, buffer.Length);
dumpCount++;
}*/
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
if (transportPacket.ErrorIndicator)
errorPackets++;
if (transportPacket.IsNullPacket)
nullPackets++;
if (!transportPacket.ErrorIndicator)
{
bool ignorePid = checkPid(transportPacket.PID, stations);
if (!ignorePid)
{
PidSpec pidSpec = findPidSpec(pidList, transportPacket.PID);
if (pidSpec == null)
{
pidSpec = new PidSpec(transportPacket.PID);
addPid(pidList, new PidSpec(transportPacket.PID));
}
pidSpec.ProcessPacket(buffer, transportPacket);
}
}
else
Logger.Instance.Write("Transport packet error in packet " + packetCount);
}
catch (ArgumentOutOfRangeException)
{
Logger.Instance.Write("Failed to parse packet " + packetCount);
}
currentOffset += buffer.Length;
}
}
Logger.Instance.Write("Analysis completed: " + pidList.Count + " PID's loaded from " + packetCount + " packets");
}
private bool fillBuffer(FileStream fileStream)
{
if (pids == null)
{
Thread.Sleep(100);
return(false);
}
if (size + 136 + packetSize > memorySize)
{
return(false);
}
byte[] buffer = new byte[packetSize];
int readCount = getPacket(fileStream, buffer);
if (readCount < packetSize)
{
return(false);
}
TransportPacket transportPacket = new TransportPacket();
try
{
transportPacket.Process(buffer);
}
catch (ArgumentOutOfRangeException)
{
Logger.Instance.Write("Sync byte error");
return(false);
}
if (RunParameters.Instance.TraceIDs.Contains("MPEG2PACKETS"))
{
if (pids[0] == -1 || pids.Contains(transportPacket.PID))
{
Logger.Instance.Dump("Simulation Packet for PID " + transportPacket.PID, buffer, buffer.Length);
}
}
if (transportPacket.ErrorIndicator)
{
return(false);
}
if (transportPacket.IsNullPacket)
{
return(false);
}
bool reply = resourceMutex.WaitOne(5000, true);
if (pids[0] == -1 || pids.Contains(transportPacket.PID))
{
Marshal.Copy(buffer, 0, offset, buffer.Length);
offset = new IntPtr(offset.ToInt64() + packetSize);
size += packetSize;
Marshal.WriteInt32(memoryBlock, size);
}
if (reply)
{
resourceMutex.ReleaseMutex();
}
return(false);
}
