more steps to make provider project portable

1 files changed, 1549 insertions, 0 deletions

diff --git a/BDInfo/TSStreamFile.cs b/BDInfo/TSStreamFile.cs
new file mode 100644
index 000000000..86cefe826
--- /dev/null
+++ b/BDInfo/TSStreamFile.cs
@@ -0,0 +1,1549 @@
+//============================================================================
+// BDInfo - Blu-ray Video and Audio Analysis Tool
+// Copyright © 2010 Cinema Squid
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//=============================================================================
+
+#undef DEBUG
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace BDInfo
+{
+    public class TSStreamState
+    {
+        public ulong TransferCount = 0;
+
+        public string StreamTag = null;
+
+        public ulong TotalPackets = 0;
+        public ulong WindowPackets = 0;
+
+        public ulong TotalBytes = 0;
+        public ulong WindowBytes = 0;
+
+        public long PeakTransferLength = 0;
+        public long PeakTransferRate = 0;
+
+        public double TransferMarker = 0;
+        public double TransferInterval = 0;
+
+        public TSStreamBuffer StreamBuffer = new TSStreamBuffer();
+
+        public uint Parse = 0;
+        public bool TransferState = false;
+        public int TransferLength = 0;
+        public int PacketLength = 0;
+        public byte PacketLengthParse = 0;
+        public byte PacketParse = 0;
+
+        public byte PTSParse = 0;
+        public ulong PTS = 0;
+        public ulong PTSTemp = 0;
+        public ulong PTSLast = 0;
+        public ulong PTSPrev = 0;
+        public ulong PTSDiff = 0;
+        public ulong PTSCount = 0;
+        public ulong PTSTransfer = 0;
+
+        public byte DTSParse = 0;
+        public ulong DTSTemp = 0;
+        public ulong DTSPrev = 0;
+
+        public byte PESHeaderLength = 0;
+        public byte PESHeaderFlags = 0;
+#if DEBUG
+        public byte PESHeaderIndex = 0;
+        public byte[] PESHeader = new byte[256 + 9];
+#endif
+    }
+
+    public class TSPacketParser
+    {
+        public bool SyncState = false;
+        public byte TimeCodeParse = 4;
+        public byte PacketLength = 0;
+        public byte HeaderParse = 0;
+
+        public uint TimeCode;
+        public byte TransportErrorIndicator;
+        public byte PayloadUnitStartIndicator;
+        public byte TransportPriority;
+        public ushort PID;
+        public byte TransportScramblingControl;
+        public byte AdaptionFieldControl;
+
+        public bool AdaptionFieldState = false;
+        public byte AdaptionFieldParse = 0;
+        public byte AdaptionFieldLength = 0;
+
+        public ushort PCRPID = 0xFFFF;
+        public byte PCRParse = 0;
+        public ulong PreviousPCR = 0;
+        public ulong PCR = 0;
+        public ulong PCRCount = 0;
+        public ulong PTSFirst = ulong.MaxValue;
+        public ulong PTSLast = ulong.MinValue;
+        public ulong PTSDiff = 0;
+
+        public byte[] PAT = new byte[1024];
+        public bool PATSectionStart = false;
+        public byte PATPointerField = 0;
+        public uint PATOffset = 0;
+        public byte PATSectionLengthParse = 0;
+        public ushort PATSectionLength = 0;
+        public uint PATSectionParse = 0;
+        public bool PATTransferState = false;
+        public byte PATSectionNumber = 0;
+        public byte PATLastSectionNumber = 0;
+
+        public ushort TransportStreamId = 0xFFFF;
+
+        public List<TSDescriptor> PMTProgramDescriptors = new List<TSDescriptor>();
+        public ushort PMTPID = 0xFFFF;
+        public Dictionary<ushort, byte[]> PMT = new Dictionary<ushort, byte[]>();
+        public bool PMTSectionStart = false;
+        public ushort PMTProgramInfoLength = 0;
+        public byte PMTProgramDescriptor = 0;
+        public byte PMTProgramDescriptorLengthParse = 0;
+        public byte PMTProgramDescriptorLength = 0;
+        public ushort PMTStreamInfoLength = 0;
+        public uint PMTStreamDescriptorLengthParse = 0;
+        public uint PMTStreamDescriptorLength = 0;
+        public byte PMTPointerField = 0;
+        public uint PMTOffset = 0;
+        public uint PMTSectionLengthParse = 0;
+        public ushort PMTSectionLength = 0;
+        public uint PMTSectionParse = 0;
+        public bool PMTTransferState = false;
+        public byte PMTSectionNumber = 0;
+        public byte PMTLastSectionNumber = 0;
+
+        public byte PMTTemp = 0;
+
+        public TSStream Stream = null;
+        public TSStreamState StreamState = null;
+
+        public ulong TotalPackets = 0;
+    }
+
+    public class TSStreamDiagnostics
+    {
+        public ulong Bytes = 0;
+        public ulong Packets = 0;
+        public double Marker = 0;
+        public double Interval = 0;
+        public string Tag = null;
+    }
+
+    public class TSStreamFile
+    {
+        public FileInfo FileInfo = null;
+        public string Name = null;
+        public long Size = 0;
+        public double Length = 0;
+
+        public TSInterleavedFile InterleavedFile = null;
+
+        private Dictionary<ushort, TSStreamState> StreamStates =
+            new Dictionary<ushort, TSStreamState>();
+
+        public Dictionary<ushort, TSStream> Streams =
+            new Dictionary<ushort, TSStream>();
+
+        public Dictionary<ushort, List<TSStreamDiagnostics>> StreamDiagnostics =
+            new Dictionary<ushort, List<TSStreamDiagnostics>>();
+
+        private List<TSPlaylistFile> Playlists = null;
+
+        public TSStreamFile(FileInfo fileInfo)
+        {
+            FileInfo = fileInfo;
+            Name = fileInfo.Name.ToUpper();
+        }
+
+        public string DisplayName
+        {
+            get
+            {
+                if (BDInfoSettings.EnableSSIF &&
+                    InterleavedFile != null)
+                {
+                    return InterleavedFile.Name;
+                }
+                return Name;
+            }
+        }
+
+        private bool ScanStream(
+            TSStream stream,
+            TSStreamState streamState,
+            TSStreamBuffer buffer)
+        {
+            streamState.StreamTag = null;
+
+            long bitrate = 0;
+            if (stream.IsAudioStream &&
+                streamState.PTSTransfer > 0)
+            {
+                bitrate = (long)Math.Round(
+                    (buffer.TransferLength * 8.0) /
+                    ((double)streamState.PTSTransfer / 90000));
+
+                if (bitrate > streamState.PeakTransferRate)
+                {
+                    streamState.PeakTransferRate = bitrate;
+                }
+            }
+            if (buffer.TransferLength > streamState.PeakTransferLength)
+            {
+                streamState.PeakTransferLength = buffer.TransferLength;
+            }
+
+            buffer.BeginRead();
+            switch (stream.StreamType)
+            {
+                case TSStreamType.MPEG2_VIDEO:
+                    TSCodecMPEG2.Scan(
+                        (TSVideoStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.AVC_VIDEO:
+                    TSCodecAVC.Scan(
+                        (TSVideoStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.MVC_VIDEO:
+                    TSCodecMVC.Scan(
+                        (TSVideoStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.VC1_VIDEO:
+                    TSCodecVC1.Scan(
+                        (TSVideoStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.AC3_AUDIO:
+                    TSCodecAC3.Scan(
+                        (TSAudioStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.AC3_PLUS_AUDIO:
+                case TSStreamType.AC3_PLUS_SECONDARY_AUDIO:
+                    TSCodecAC3.Scan(
+                        (TSAudioStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.AC3_TRUE_HD_AUDIO:
+                    TSCodecTrueHD.Scan(
+                        (TSAudioStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.LPCM_AUDIO:
+                    TSCodecLPCM.Scan(
+                        (TSAudioStream)stream, buffer, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.DTS_AUDIO:
+                    TSCodecDTS.Scan(
+                        (TSAudioStream)stream, buffer, bitrate, ref streamState.StreamTag);
+                    break;
+
+                case TSStreamType.DTS_HD_AUDIO:
+                case TSStreamType.DTS_HD_MASTER_AUDIO:
+                case TSStreamType.DTS_HD_SECONDARY_AUDIO:
+                    TSCodecDTSHD.Scan(
+                        (TSAudioStream)stream, buffer, bitrate, ref streamState.StreamTag);
+                    break;
+
+                default:
+                    stream.IsInitialized = true;
+                    break;
+            }
+            buffer.EndRead();
+            streamState.StreamBuffer.Reset();
+
+            bool isAVC = false;
+            bool isMVC = false;
+            foreach (TSStream finishedStream in Streams.Values)
+            {
+                if (!finishedStream.IsInitialized)
+                {
+                    return false;
+                }
+                if (finishedStream.StreamType == TSStreamType.AVC_VIDEO)
+                {
+                    isAVC = true;
+                }
+                if (finishedStream.StreamType == TSStreamType.MVC_VIDEO)
+                {
+                    isMVC = true;
+                }
+            }
+            if (isMVC && !isAVC)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        private void UpdateStreamBitrates(
+            ushort PTSPID,
+            ulong PTS,
+            ulong PTSDiff)
+        {
+            if (Playlists == null) return;
+
+            foreach (ushort PID in StreamStates.Keys)
+            {
+                if (Streams.ContainsKey(PID) &&
+                    Streams[PID].IsVideoStream &&
+                    PID != PTSPID)
+                {
+                    continue;
+                }
+                if (StreamStates[PID].WindowPackets == 0)
+                {
+                    continue;
+                }
+                UpdateStreamBitrate(PID, PTSPID, PTS, PTSDiff);
+            }
+
+            foreach (TSPlaylistFile playlist in Playlists)
+            {
+                double packetSeconds = 0;
+                foreach (TSStreamClip clip in playlist.StreamClips)
+                {
+                    if (clip.AngleIndex == 0)
+                    {
+                        packetSeconds += clip.PacketSeconds;
+                    }
+                }
+                if (packetSeconds > 0)
+                {
+                    foreach (TSStream playlistStream in playlist.SortedStreams)
+                    {
+                        if (playlistStream.IsVBR)
+                        {
+                            playlistStream.BitRate = (long)Math.Round(
+                                ((playlistStream.PayloadBytes * 8.0) / packetSeconds));
+
+                            if (playlistStream.StreamType == TSStreamType.AC3_TRUE_HD_AUDIO &&
+                                ((TSAudioStream)playlistStream).CoreStream != null)
+                            {
+                                playlistStream.BitRate -=
+                                    ((TSAudioStream)playlistStream).CoreStream.BitRate;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void UpdateStreamBitrate(
+            ushort PID,
+            ushort PTSPID,
+            ulong PTS,
+            ulong PTSDiff)
+        {
+            if (Playlists == null) return;
+
+            TSStreamState streamState = StreamStates[PID];
+            double streamTime = (double)PTS / 90000;
+            double streamInterval = (double)PTSDiff / 90000;
+            double streamOffset = streamTime + streamInterval;
+
+            foreach (TSPlaylistFile playlist in Playlists)
+            {
+                foreach (TSStreamClip clip in playlist.StreamClips)
+                {
+                    if (clip.Name != this.Name) continue;
+
+                    if (streamTime == 0 ||
+                        (streamTime >= clip.TimeIn &&
+                         streamTime <= clip.TimeOut))
+                    {
+                        clip.PayloadBytes += streamState.WindowBytes;
+                        clip.PacketCount += streamState.WindowPackets;
+
+                        if (streamOffset > clip.TimeIn &&
+                            streamOffset - clip.TimeIn > clip.PacketSeconds)
+                        {
+                            clip.PacketSeconds = streamOffset - clip.TimeIn;
+                        }
+
+                        Dictionary<ushort, TSStream> playlistStreams = playlist.Streams;
+                        if (clip.AngleIndex > 0 && 
+                            clip.AngleIndex < playlist.AngleStreams.Count + 1)
+                        {
+                            playlistStreams = playlist.AngleStreams[clip.AngleIndex - 1];
+                        }
+                        if (playlistStreams.ContainsKey(PID))
+                        {
+                            TSStream stream = playlistStreams[PID];
+
+                            stream.PayloadBytes += streamState.WindowBytes;
+                            stream.PacketCount += streamState.WindowPackets;
+
+                            if (stream.IsVideoStream)
+                            {
+                                stream.PacketSeconds += streamInterval;
+
+                                stream.ActiveBitRate = (long)Math.Round(
+                                    ((stream.PayloadBytes * 8.0) /
+                                    stream.PacketSeconds));
+                            }
+
+                            if (stream.StreamType == TSStreamType.AC3_TRUE_HD_AUDIO &&
+                                ((TSAudioStream)stream).CoreStream != null)
+                            {
+                                stream.ActiveBitRate -=
+                                    ((TSAudioStream)stream).CoreStream.BitRate;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (Streams.ContainsKey(PID))
+            {
+                TSStream stream = Streams[PID];
+                stream.PayloadBytes += streamState.WindowBytes;
+                stream.PacketCount += streamState.WindowPackets;
+                
+                if (stream.IsVideoStream)
+                {
+                    TSStreamDiagnostics diag = new TSStreamDiagnostics();
+                    diag.Marker = (double)PTS / 90000;
+                    diag.Interval = (double)PTSDiff / 90000;
+                    diag.Bytes = streamState.WindowBytes;
+                    diag.Packets = streamState.WindowPackets;
+                    diag.Tag = streamState.StreamTag;
+                    StreamDiagnostics[PID].Add(diag);
+
+                    stream.PacketSeconds += streamInterval;
+                }
+            }
+            streamState.WindowPackets = 0;
+            streamState.WindowBytes = 0;
+        }
+
+        public void Scan(List<TSPlaylistFile> playlists, bool isFullScan)
+        {
+            if (playlists == null || playlists.Count == 0)
+            {
+                return;
+            }
+
+            Playlists = playlists;
+            int dataSize = 16384;
+            FileStream fileStream = null;
+            try
+            {                
+                string fileName;
+                if (BDInfoSettings.EnableSSIF &&
+                    InterleavedFile != null)
+                {
+                    fileName = InterleavedFile.FileInfo.FullName;
+                }
+                else
+                {
+                    fileName = FileInfo.FullName;
+                }
+                fileStream = new FileStream(
+                    fileName,
+                    FileMode.Open,
+                    FileAccess.Read,
+                    FileShare.Read,
+                    dataSize, false);
+
+                Size = 0;
+                Length = 0;
+
+                Streams.Clear();
+                StreamStates.Clear();
+                StreamDiagnostics.Clear();
+
+                TSPacketParser parser = 
+                    new TSPacketParser();
+                
+                long fileLength = (uint)fileStream.Length;
+                byte[] buffer = new byte[dataSize];
+                int bufferLength = 0;
+                while ((bufferLength = 
+                    fileStream.Read(buffer, 0, buffer.Length)) > 0)
+                {
+                    int offset = 0;
+                    for (int i = 0; i < bufferLength; i++)
+                    {
+                        if (parser.SyncState == false)
+                        {
+                            if (parser.TimeCodeParse > 0)
+                            {
+                                parser.TimeCodeParse--;
+                                switch (parser.TimeCodeParse)
+                                {
+                                    case 3:
+                                        parser.TimeCode = 0;
+                                        parser.TimeCode |=
+                                            ((uint)buffer[i] & 0x3F) << 24;
+                                        break;
+                                    case 2:
+                                        parser.TimeCode |=
+                                            ((uint)buffer[i] & 0xFF) << 16;
+                                        break;
+                                    case 1:
+                                        parser.TimeCode |=
+                                            ((uint)buffer[i] & 0xFF) << 8;
+                                        break;
+                                    case 0:
+                                        parser.TimeCode |=
+                                            ((uint)buffer[i] & 0xFF);
+                                        break;
+                                }
+                            }
+                            else if (buffer[i] == 0x47)
+                            {
+                                parser.SyncState = true;
+                                parser.PacketLength = 187;
+                                parser.TimeCodeParse = 4;
+                                parser.HeaderParse = 3;
+                            }
+                        }
+                        else if (parser.HeaderParse > 0)
+                        {
+                            parser.PacketLength--;
+                            parser.HeaderParse--;
+
+                            switch (parser.HeaderParse)
+                            {
+                                case 2:
+                                {
+                                    parser.TransportErrorIndicator =
+                                        (byte)((buffer[i] >> 7) & 0x1);
+                                    parser.PayloadUnitStartIndicator =
+                                        (byte)((buffer[i] >> 6) & 0x1);
+                                    parser.TransportPriority =
+                                        (byte)((buffer[i] >> 5) & 0x1);
+                                    parser.PID =
+                                        (ushort)((buffer[i] & 0x1f) << 8);
+                                }
+                                break;
+
+                                case 1:
+                                {
+                                    parser.PID |= (ushort)buffer[i];
+                                    if (Streams.ContainsKey(parser.PID))
+                                    {
+                                        parser.Stream = Streams[parser.PID];
+                                    }
+                                    else
+                                    {
+                                        parser.Stream = null;
+                                    }
+                                    if (!StreamStates.ContainsKey(parser.PID))
+                                    {
+                                        StreamStates[parser.PID] = new TSStreamState();
+                                    }
+                                    parser.StreamState = StreamStates[parser.PID];
+                                    parser.StreamState.TotalPackets++;
+                                    parser.StreamState.WindowPackets++;
+                                    parser.TotalPackets++;
+                                }
+                                break;
+
+                                case 0:
+                                {
+                                    parser.TransportScramblingControl =
+                                        (byte)((buffer[i] >> 6) & 0x3);
+                                    parser.AdaptionFieldControl =
+                                        (byte)((buffer[i] >> 4) & 0x3);
+
+                                    if ((parser.AdaptionFieldControl & 0x2) == 0x2)
+                                    {
+                                        parser.AdaptionFieldState = true;
+                                    }
+                                    if (parser.PayloadUnitStartIndicator == 1)
+                                    {
+                                        if (parser.PID == 0)
+                                        {
+                                            parser.PATSectionStart = true;
+                                        }
+                                        else if (parser.PID == parser.PMTPID)
+                                        {
+                                            parser.PMTSectionStart = true;
+                                        }
+                                        else if (parser.StreamState != null &&
+                                            parser.StreamState.TransferState)
+                                        {
+                                            parser.StreamState.TransferState = false;
+                                            parser.StreamState.TransferCount++;
+
+                                            bool isFinished = ScanStream(
+                                                parser.Stream, 
+                                                parser.StreamState, 
+                                                parser.StreamState.StreamBuffer);
+
+                                            if (!isFullScan && isFinished)
+                                            {
+                                                return;
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        else if (parser.AdaptionFieldState)
+                        {
+                            parser.PacketLength--;
+                            parser.AdaptionFieldParse = buffer[i];
+                            parser.AdaptionFieldLength = buffer[i];
+                            parser.AdaptionFieldState = false;
+                        }
+                        else if (parser.AdaptionFieldParse > 0)
+                        {
+                            parser.PacketLength--;
+                            parser.AdaptionFieldParse--;
+                            if ((parser.AdaptionFieldLength - parser.AdaptionFieldParse) == 1)
+                            {
+                                if ((buffer[i] & 0x10) == 0x10)
+                                {
+                                    parser.PCRParse = 6;
+                                    parser.PCR = 0;
+                                }
+                            }
+                            else if (parser.PCRParse > 0)
+                            {
+                                parser.PCRParse--;
+                                parser.PCR = (parser.PCR << 8) + (ulong)buffer[i];
+                                if (parser.PCRParse == 0)
+                                {
+                                    parser.PreviousPCR = parser.PCR;
+                                    parser.PCR = (parser.PCR & 0x1FF) +
+                                        ((parser.PCR >> 15) * 300);
+                                }
+                                parser.PCRCount++;
+                            }
+                            if (parser.PacketLength == 0)
+                            {
+                                parser.SyncState = false;
+                            }
+                        }
+                        else if (parser.PID == 0)
+                        {
+                            if (parser.PATTransferState)
+                            {
+                                if ((bufferLength - i) > parser.PATSectionLength)
+                                {
+                                    offset = parser.PATSectionLength;
+                                }
+                                else
+                                {
+                                    offset = (bufferLength - i);
+                                }
+                                if (parser.PacketLength <= offset)
+                                {
+                                    offset = parser.PacketLength;
+                                }
+
+                                for (int k = 0; k < offset; k++)
+                                {
+                                    parser.PAT[parser.PATOffset++] = buffer[i++];
+                                    parser.PATSectionLength--;
+                                    parser.PacketLength--;
+                                } --i;
+
+                                if (parser.PATSectionLength == 0)
+                                {
+                                    parser.PATTransferState = false;
+                                    if (parser.PATSectionNumber == parser.PATLastSectionNumber)
+                                    {
+                                        for (int k = 0; k < (parser.PATOffset - 4); k += 4)
+                                        {
+                                            uint programNumber = (uint)
+                                                ((parser.PAT[k] << 8) +  
+                                                  parser.PAT[k + 1]);
+
+                                            ushort programPID = (ushort)                                                 
+                                                (((parser.PAT[k + 2] & 0x1F) << 8) +
+                                                   parser.PAT[k + 3]);
+
+                                            if (programNumber == 1)
+                                            {
+                                                parser.PMTPID = programPID;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                --parser.PacketLength;
+                                if (parser.PATSectionStart)
+                                {
+                                    parser.PATPointerField = buffer[i];
+                                    if (parser.PATPointerField == 0)
+                                    {
+                                        parser.PATSectionLengthParse = 3;
+                                    }
+                                    parser.PATSectionStart = false;
+                                }
+                                else if (parser.PATPointerField > 0)
+                                {
+                                    --parser.PATPointerField;
+                                    if (parser.PATPointerField == 0)
+                                    {
+                                        parser.PATSectionLengthParse = 3;
+                                    }
+                                }
+                                else if (parser.PATSectionLengthParse > 0)
+                                {
+                                    --parser.PATSectionLengthParse;
+                                    switch (parser.PATSectionLengthParse)
+                                    {
+                                        case 2:
+                                            break;
+                                        case 1:
+                                            parser.PATSectionLength = (ushort)
+                                                ((buffer[i] & 0xF) << 8);
+                                            break;
+                                        case 0:
+                                            parser.PATSectionLength |= buffer[i];
+                                            if (parser.PATSectionLength > 1021)
+                                            {
+                                                parser.PATSectionLength = 0;
+                                            }
+                                            else
+                                            {
+                                                parser.PATSectionParse = 5;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (parser.PATSectionParse > 0)
+                                {
+                                    --parser.PATSectionLength;
+                                    --parser.PATSectionParse;
+
+                                    switch (parser.PATSectionParse)
+                                    {
+                                        case 4:
+                                            parser.TransportStreamId = (ushort)
+                                                (buffer[i] << 8);
+                                            break;
+                                        case 3:
+                                            parser.TransportStreamId |= buffer[i];
+                                            break;
+                                        case 2:
+                                            break;
+                                        case 1:
+                                            parser.PATSectionNumber = buffer[i];
+                                            if (parser.PATSectionNumber == 0)
+                                            {
+                                                parser.PATOffset = 0;
+                                            }
+                                            break;
+                                        case 0:
+                                            parser.PATLastSectionNumber = buffer[i];
+                                            parser.PATTransferState = true;
+                                            break;
+                                    }
+                                }
+                            }
+                            if (parser.PacketLength == 0)
+                            {
+                                parser.SyncState = false;
+                            }
+                        }
+                        else if (parser.PID == parser.PMTPID)
+                        {
+                            if (parser.PMTTransferState)
+                            {
+                                if ((bufferLength - i) >= parser.PMTSectionLength)
+                                {
+                                    offset = parser.PMTSectionLength;
+                                }
+                                else
+                                {
+                                    offset = (bufferLength - i);
+                                }
+                                if (parser.PacketLength <= offset)
+                                {
+                                    offset = parser.PacketLength;
+                                }
+                                if (!parser.PMT.ContainsKey(parser.PID))
+                                {
+                                    parser.PMT[parser.PID] = new byte[1024];
+                                }
+
+                                byte[] PMT = parser.PMT[parser.PID];
+                                for (int k = 0; k < offset; k++)
+                                {
+                                    PMT[parser.PMTOffset++] = buffer[i++];
+                                    --parser.PMTSectionLength;
+                                    --parser.PacketLength;
+                                } --i;
+
+                                if (parser.PMTSectionLength == 0)
+                                {
+                                    parser.PMTTransferState = false;
+                                    if (parser.PMTSectionNumber == parser.PMTLastSectionNumber)
+                                    {
+                                        //Console.WriteLine("PMT Start: " + parser.PMTTemp);
+                                        try
+                                        {
+                                            for (int k = 0; k < (parser.PMTOffset - 4); k += 5)
+                                            {
+                                                byte streamType = PMT[k];
+
+                                                ushort streamPID = (ushort)
+                                                    (((PMT[k + 1] & 0x1F) << 8) +
+                                                       PMT[k + 2]);
+
+                                                ushort streamInfoLength = (ushort)
+                                                    (((PMT[k + 3] & 0xF) << 8) +
+                                                       PMT[k + 4]);
+
+                                                /*
+                                                if (streamInfoLength == 2)
+                                                {
+                                                    // TODO: Cleanup
+                                                    //streamInfoLength = 0;
+                                                }
+
+                                                Console.WriteLine(string.Format(
+                                                    "Type: {0} PID: {1} Length: {2}",
+                                                    streamType, streamPID, streamInfoLength));
+                                                 */
+
+                                                if (!Streams.ContainsKey(streamPID))
+                                                {
+                                                    List<TSDescriptor> streamDescriptors =
+                                                        new List<TSDescriptor>();
+
+                                                    /*
+                                                     * TODO: Getting bad streamInfoLength
+                                                    if (streamInfoLength > 0)
+                                                    {
+                                                        for (int d = 0; d < streamInfoLength; d++)
+                                                        {
+                                                            byte name = PMT[k + d + 5];
+                                                            byte length = PMT[k + d + 6];
+                                                            TSDescriptor descriptor =
+                                                                new TSDescriptor(name, length);
+                                                            for (int v = 0; v < length; v++)
+                                                            {
+                                                                descriptor.Value[v] =
+                                                                    PMT[k + d + v + 7];
+                                                            }
+                                                            streamDescriptors.Add(descriptor);
+                                                            d += (length + 1);
+                                                        }
+                                                    }
+                                                    */
+                                                    CreateStream(streamPID, streamType, streamDescriptors);
+                                                }
+                                                k += streamInfoLength;
+                                            }
+                                        }
+                                        catch (Exception ex)
+                                        {
+                                            // TODO
+                                            //Console.WriteLine(ex.Message);
+                                        }
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                --parser.PacketLength;
+                                if (parser.PMTSectionStart)
+                                {
+                                    parser.PMTPointerField = buffer[i];
+                                    if (parser.PMTPointerField == 0)
+                                    {
+                                        parser.PMTSectionLengthParse = 3;
+                                    }
+                                    parser.PMTSectionStart = false;
+                                }
+                                else if (parser.PMTPointerField > 0)
+                                {
+                                    --parser.PMTPointerField;
+                                    if (parser.PMTPointerField == 0)
+                                    {
+                                        parser.PMTSectionLengthParse = 3;
+                                    }
+                                }
+                                else if (parser.PMTSectionLengthParse > 0)
+                                {
+                                    --parser.PMTSectionLengthParse;
+                                    switch (parser.PMTSectionLengthParse)
+                                    {
+                                        case 2:
+                                            if (buffer[i] != 0x2)
+                                            {
+                                                parser.PMTSectionLengthParse = 0;
+                                            }
+                                            break;
+                                        case 1:
+                                            parser.PMTSectionLength = (ushort)
+                                                ((buffer[i] & 0xF) << 8);
+                                            break;
+                                        case 0:
+                                            parser.PMTSectionLength |= buffer[i];
+                                            if (parser.PMTSectionLength > 1021)
+                                            {
+                                                parser.PMTSectionLength = 0;
+                                            }
+                                            else
+                                            {
+                                                parser.PMTSectionParse = 9;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (parser.PMTSectionParse > 0)
+                                {
+                                    --parser.PMTSectionLength;
+                                    --parser.PMTSectionParse;
+
+                                    switch (parser.PMTSectionParse)
+                                    {
+                                        case 8:
+                                        case 7:
+                                            break;
+                                        case 6:
+                                            parser.PMTTemp = buffer[i];
+                                            break;
+                                        case 5:
+                                            parser.PMTSectionNumber = buffer[i];
+                                            if (parser.PMTSectionNumber == 0)
+                                            {
+                                                parser.PMTOffset = 0;
+                                            }
+                                            break;
+                                        case 4:
+                                            parser.PMTLastSectionNumber = buffer[i];
+                                            break;
+                                        case 3:
+                                            parser.PCRPID = (ushort)
+                                                ((buffer[i] & 0x1F) << 8);
+                                            break;
+                                        case 2:
+                                            parser.PCRPID |= buffer[i];
+                                            break;
+                                        case 1:
+                                            parser.PMTProgramInfoLength = (ushort)
+                                                ((buffer[i] & 0xF) << 8);
+                                            break;
+                                        case 0:
+                                            parser.PMTProgramInfoLength |= buffer[i];
+                                            if (parser.PMTProgramInfoLength == 0)
+                                            {
+                                                parser.PMTTransferState = true;
+                                            }
+                                            else
+                                            {
+                                                parser.PMTProgramDescriptorLengthParse = 2;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (parser.PMTProgramInfoLength > 0)
+                                {
+                                    --parser.PMTSectionLength;
+                                    --parser.PMTProgramInfoLength;
+
+                                    if (parser.PMTProgramDescriptorLengthParse > 0)
+                                    {
+                                        --parser.PMTProgramDescriptorLengthParse;
+                                        switch (parser.PMTProgramDescriptorLengthParse)
+                                        {
+                                            case 1:
+                                                parser.PMTProgramDescriptor = buffer[i];
+                                                break;
+                                            case 0:
+                                                parser.PMTProgramDescriptorLength = buffer[i];
+                                                parser.PMTProgramDescriptors.Add(
+                                                    new TSDescriptor(
+                                                        parser.PMTProgramDescriptor, 
+                                                        parser.PMTProgramDescriptorLength));
+                                                break;
+                                        }
+                                    }
+                                    else if (parser.PMTProgramDescriptorLength > 0)
+                                    {
+                                        --parser.PMTProgramDescriptorLength;
+
+                                        TSDescriptor descriptor = parser.PMTProgramDescriptors[
+                                            parser.PMTProgramDescriptors.Count - 1];
+
+                                        int valueIndex =
+                                            descriptor.Value.Length - 
+                                            parser.PMTProgramDescriptorLength - 1;
+
+                                        descriptor.Value[valueIndex] = buffer[i];
+
+                                        if (parser.PMTProgramDescriptorLength == 0 &&
+                                            parser.PMTProgramInfoLength > 0)
+                                        {
+                                            parser.PMTProgramDescriptorLengthParse = 2;
+                                        }
+                                    }
+                                    if (parser.PMTProgramInfoLength == 0)
+                                    {
+                                        parser.PMTTransferState = true;
+                                    }
+                                }
+                            }
+                            if (parser.PacketLength == 0)
+                            {
+                                parser.SyncState = false;
+                            }
+                        }
+                        else if (parser.Stream != null && 
+                            parser.StreamState != null && 
+                            parser.TransportScramblingControl == 0)
+                        {
+                            TSStream stream = parser.Stream;
+                            TSStreamState streamState = parser.StreamState;
+
+                            streamState.Parse =
+                                (streamState.Parse << 8) + buffer[i];
+
+                            if (streamState.TransferState)
+                            {
+                                if ((bufferLength - i) >= streamState.PacketLength && 
+                                    streamState.PacketLength > 0)
+                                {
+                                    offset = streamState.PacketLength;
+                                }
+                                else
+                                {
+                                    offset = (bufferLength - i);
+                                }
+                                if (parser.PacketLength <= offset)
+                                {
+                                    offset = parser.PacketLength;
+                                }
+                                streamState.TransferLength = offset;
+
+                                if (!stream.IsInitialized ||
+                                    stream.IsVideoStream)
+                                {
+                                    streamState.StreamBuffer.Add(
+                                        buffer, i, offset);
+                                }
+                                else
+                                {
+                                    streamState.StreamBuffer.TransferLength += offset;
+                                }
+
+                                i += (int)(streamState.TransferLength - 1);
+                                streamState.PacketLength -= streamState.TransferLength;
+                                parser.PacketLength -= (byte)streamState.TransferLength;
+
+                                streamState.TotalBytes += (ulong)streamState.TransferLength;
+                                streamState.WindowBytes += (ulong)streamState.TransferLength;
+
+                                if (streamState.PacketLength == 0)
+                                {
+                                    streamState.TransferState = false;
+                                    streamState.TransferCount++;
+                                    bool isFinished = ScanStream(
+                                        stream,
+                                        streamState,
+                                        streamState.StreamBuffer);
+
+                                    if (!isFullScan && isFinished)
+                                    {
+                                        return;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                --parser.PacketLength;
+
+                                bool headerFound = false;
+                                if (stream.IsVideoStream && 
+                                    streamState.Parse == 0x000001FD)
+                                {
+                                    headerFound = true;
+                                }
+                                if (stream.IsVideoStream &&
+                                    streamState.Parse >= 0x000001E0 &&
+                                    streamState.Parse <= 0x000001EF)
+                                {
+                                    headerFound = true;
+                                }
+                                if (stream.IsAudioStream &&
+                                    streamState.Parse == 0x000001BD)
+                                {
+                                    headerFound = true;
+                                }
+                                if (stream.IsAudioStream &&
+                                    (streamState.Parse == 0x000001FA ||
+                                     streamState.Parse == 0x000001FD))
+                                {
+                                    headerFound = true;
+                                }
+
+                                if (!stream.IsVideoStream &&
+                                    !stream.IsAudioStream &&
+                                    (streamState.Parse == 0x000001FA ||
+                                     streamState.Parse == 0x000001FD ||
+                                     streamState.Parse == 0x000001BD ||
+                                     (streamState.Parse >= 0x000001E0 &&
+                                      streamState.Parse <= 0x000001EF)))
+                                {
+                                    headerFound = true;
+                                }
+
+                                if (headerFound)
+                                {
+                                    streamState.PacketLengthParse = 2;
+#if DEBUG
+                                    streamState.PESHeaderIndex = 0;
+                                    streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                        (byte)((streamState.Parse >> 24) & 0xFF);
+                                    streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                        (byte)((streamState.Parse >> 16) & 0xFF);
+                                    streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                        (byte)((streamState.Parse >> 8) & 0xFF);
+                                    streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                        (byte)(streamState.Parse & 0xFF);
+#endif
+                                }
+                                else if (streamState.PacketLengthParse > 0)
+                                {
+                                    --streamState.PacketLengthParse;
+                                    switch (streamState.PacketLengthParse)
+                                    {
+                                        case 1:
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+
+                                        case 0:
+                                            streamState.PacketLength =
+                                                (int)(streamState.Parse & 0xFFFF);
+                                            streamState.PacketParse = 3;
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                    }
+                                }
+                                else if (streamState.PacketParse > 0)
+                                {
+                                    --streamState.PacketLength;
+                                    --streamState.PacketParse;
+
+                                    switch (streamState.PacketParse)
+                                    {
+                                        case 2:
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 1:
+                                            streamState.PESHeaderFlags = 
+                                                (byte)(streamState.Parse & 0xFF);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 0:
+                                            streamState.PESHeaderLength = 
+                                                (byte)(streamState.Parse & 0xFF);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            if ((streamState.PESHeaderFlags & 0xC0) == 0x80)
+                                            {
+                                                streamState.PTSParse = 5;
+                                            }
+                                            else if ((streamState.PESHeaderFlags & 0xC0) == 0xC0)
+                                            {
+                                                streamState.DTSParse = 10;
+                                            }
+                                            if (streamState.PESHeaderLength == 0)
+                                            {
+                                                streamState.TransferState = true;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (streamState.PTSParse > 0)
+                                {
+                                    --streamState.PacketLength;
+                                    --streamState.PESHeaderLength;
+                                    --streamState.PTSParse;
+
+                                    switch (streamState.PTSParse)
+                                    {
+                                        case 4:
+                                            streamState.PTSTemp = 
+                                                ((streamState.Parse & 0xE) << 29);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            break;
+                                        
+                                        case 3:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 22);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 2:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFE) << 14);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 1:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 7);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 0:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFE) >> 1);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif                                        
+                                            streamState.PTS = streamState.PTSTemp;
+
+                                            if (streamState.PTS > streamState.PTSLast)
+                                            {
+                                                if (streamState.PTSLast > 0)
+                                                {
+                                                    streamState.PTSTransfer = (streamState.PTS - streamState.PTSLast);
+                                                }                                                
+                                                streamState.PTSLast = streamState.PTS;
+                                            }
+
+                                            streamState.PTSDiff = streamState.PTS - streamState.DTSPrev;
+
+                                            if (streamState.PTSCount > 0 && 
+                                                stream.IsVideoStream)
+                                            {
+                                                UpdateStreamBitrates(stream.PID, streamState.PTS, streamState.PTSDiff);
+                                                if (streamState.DTSTemp < parser.PTSFirst)
+                                                {
+                                                    parser.PTSFirst = streamState.DTSTemp;
+                                                }
+                                                if (streamState.DTSTemp > parser.PTSLast)
+                                                {
+                                                    parser.PTSLast = streamState.DTSTemp;
+                                                }
+                                                Length = (double)(parser.PTSLast - parser.PTSFirst) / 90000;
+                                            }
+                                            
+                                            streamState.DTSPrev = streamState.PTS;
+                                            streamState.PTSCount++;
+                                            if (streamState.PESHeaderLength == 0)
+                                            {
+                                                streamState.TransferState = true;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (streamState.DTSParse > 0)
+                                {
+                                    --streamState.PacketLength;
+                                    --streamState.PESHeaderLength;
+                                    --streamState.DTSParse;
+
+                                    switch (streamState.DTSParse)
+                                    {
+                                        case 9:
+                                            streamState.PTSTemp = 
+                                                ((streamState.Parse & 0xE) << 29);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 8:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 22);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 7:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFE) << 14);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            break;
+                                        
+                                        case 6:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 7);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 5:
+                                            streamState.PTSTemp |= 
+                                                ((streamState.Parse & 0xFE) >> 1);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            streamState.PTS = streamState.PTSTemp;
+                                            if (streamState.PTS > streamState.PTSLast)
+                                            {
+                                                streamState.PTSLast = streamState.PTS;
+                                            }
+                                            break;
+                                        
+                                        case 4:
+                                            streamState.DTSTemp = 
+                                                ((streamState.Parse & 0xE) << 29);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            break;
+                                        
+                                        case 3:
+                                            streamState.DTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 22);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            break;
+                                        
+                                        case 2:
+                                            streamState.DTSTemp |= 
+                                                ((streamState.Parse & 0xFE) << 14);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            break;
+                                        
+                                        case 1:
+                                            streamState.DTSTemp |= 
+                                                ((streamState.Parse & 0xFF) << 7);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xFF);
+#endif
+                                            break;
+                                        
+                                        case 0:
+                                            streamState.DTSTemp |= 
+                                                ((streamState.Parse & 0xFE) >> 1);
+#if DEBUG
+                                            streamState.PESHeader[streamState.PESHeaderIndex++] = 
+                                                (byte)(streamState.Parse & 0xff);
+#endif
+                                            streamState.PTSDiff = streamState.DTSTemp - streamState.DTSPrev;
+
+                                            if (streamState.PTSCount > 0 &&
+                                                stream.IsVideoStream)
+                                            {
+                                                UpdateStreamBitrates(stream.PID, streamState.DTSTemp, streamState.PTSDiff);
+                                                if (streamState.DTSTemp < parser.PTSFirst)
+                                                {
+                                                    parser.PTSFirst = streamState.DTSTemp;
+                                                }
+                                                if (streamState.DTSTemp > parser.PTSLast)
+                                                {
+                                                    parser.PTSLast = streamState.DTSTemp;
+                                                }
+                                                Length = (double)(parser.PTSLast - parser.PTSFirst) / 90000;
+                                            }
+                                            streamState.DTSPrev = streamState.DTSTemp;
+                                            streamState.PTSCount++;
+                                            if (streamState.PESHeaderLength == 0)
+                                            {
+                                                streamState.TransferState = true;
+                                            }
+                                            break;
+                                    }
+                                }
+                                else if (streamState.PESHeaderLength > 0)
+                                {
+                                    --streamState.PacketLength;
+                                    --streamState.PESHeaderLength;
+#if DEBUG
+                                    streamState.PESHeader[streamState.PESHeaderIndex++] =
+                                        (byte)(streamState.Parse & 0xFF);
+#endif
+                                    if (streamState.PESHeaderLength == 0)
+                                    {
+                                        streamState.TransferState = true;
+                                    }
+                                }
+                            }
+                            if (parser.PacketLength == 0)
+                            {
+                                parser.SyncState = false;
+                            }
+                        }
+                        else
+                        {
+                            parser.PacketLength--;
+                            if ((bufferLength - i) >= parser.PacketLength)
+                            {
+                                i = i + parser.PacketLength;
+                                parser.PacketLength = 0;
+                            }
+                            else
+                            {
+                                parser.PacketLength -= (byte)((bufferLength - i) + 1);
+                                i = bufferLength;
+                            }
+                            if (parser.PacketLength == 0)
+                            {
+                                parser.SyncState = false;
+                            }
+                        }
+                    }
+                    Size += bufferLength;
+                }
+
+                ulong PTSLast = 0;
+                ulong PTSDiff = 0;
+                foreach (TSStream stream in Streams.Values)
+                {
+                    if (!stream.IsVideoStream) continue;
+
+                    if (StreamStates.ContainsKey(stream.PID) &&
+                        StreamStates[stream.PID].PTSLast > PTSLast)
+                    {
+                        PTSLast = StreamStates[stream.PID].PTSLast;
+                        PTSDiff = PTSLast - StreamStates[stream.PID].DTSPrev;
+                    }
+                    UpdateStreamBitrates(stream.PID, PTSLast, PTSDiff);
+                }
+            }
+            finally
+            {
+                if (fileStream != null)
+                {
+                    fileStream.Dispose();
+                }
+            }
+        }
+
+        private TSStream CreateStream(
+            ushort streamPID, 
+            byte streamType, 
+            List<TSDescriptor> streamDescriptors)
+        {
+            TSStream stream = null;
+
+            switch ((TSStreamType)streamType)
+            {
+                case TSStreamType.MVC_VIDEO:
+                case TSStreamType.AVC_VIDEO:
+                case TSStreamType.MPEG1_VIDEO:
+                case TSStreamType.MPEG2_VIDEO:
+                case TSStreamType.VC1_VIDEO:
+                {
+                    stream = new TSVideoStream();
+                }
+                break;
+
+                case TSStreamType.AC3_AUDIO:
+                case TSStreamType.AC3_PLUS_AUDIO:
+                case TSStreamType.AC3_PLUS_SECONDARY_AUDIO:
+                case TSStreamType.AC3_TRUE_HD_AUDIO:
+                case TSStreamType.DTS_AUDIO:
+                case TSStreamType.DTS_HD_AUDIO:
+                case TSStreamType.DTS_HD_MASTER_AUDIO:
+                case TSStreamType.DTS_HD_SECONDARY_AUDIO:
+                case TSStreamType.LPCM_AUDIO:
+                case TSStreamType.MPEG1_AUDIO:
+                case TSStreamType.MPEG2_AUDIO:
+                {
+                    stream = new TSAudioStream();
+                }
+                break;
+
+                case TSStreamType.INTERACTIVE_GRAPHICS:
+                case TSStreamType.PRESENTATION_GRAPHICS:
+                {
+                    stream = new TSGraphicsStream();
+                }
+                break;
+
+                case TSStreamType.SUBTITLE:
+                {
+                    stream = new TSTextStream();
+                }
+                break;
+
+                default:
+                    break;
+            }
+
+            if (stream != null &&
+                !Streams.ContainsKey(streamPID))
+            {
+                stream.PID = streamPID;
+                stream.StreamType = (TSStreamType)streamType;
+                stream.Descriptors = streamDescriptors;
+                Streams[stream.PID] = stream;
+            }
+            if (!StreamDiagnostics.ContainsKey(streamPID))
+            {
+                StreamDiagnostics[streamPID] =
+                    new List<TSStreamDiagnostics>();
+            }
+
+            return stream;
+        } 
+    }
+}