MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Linq;

using System.Diagnostics;

using System.IO;

using System.Globalization;

using System.Net;

namespace ImageFields

{

    internal class SmoothStreamingFile : IDisposable

    {

        // Fields

        private static long factor = 0x3b9aca00L;

        private MemoryStream memoryStream;

        private MP4File[] mp4files = new MP4File[0x20];

        private string rootFileName;

        private static char[] splitarray = new char[] { '\\', '_', '.' };

        // Methods

        public SmoothStreamingFile(string fileName)

        {

            this.rootFileName = fileName;

            this.memoryStream = new MemoryStream(0x6000);

        }

        public void Close()

        {

            this.Dispose();

        }

        public void CreateDirectory(object o, DirectoryEventArgs e)

        {

        }

        public void Dispose()

        {

            int maxlevel = 0;

            for (int i = 0; i < 0x20; i++)

            {

                if (this.mp4files[i] != null)

                {

                    this.mp4files[i].Close();

                    this.mp4files[i] = null;

                    maxlevel = i;

                }

            }

            this.WriteServerManifest(maxlevel);

            this.memoryStream.Close();

            this.memoryStream = null;

            GC.SuppressFinalize(this);

        }

        ~SmoothStreamingFile()

        {

            this.Dispose();

        }

        private string GetFileName(int level)

        {

            return (Path.ChangeExtension(this.rootFileName, null) + "_" + level.ToString("00", CultureInfo.InvariantCulture) + ".ismv");

        }

        public static void InputCompleted(object o, StreamEventArgs e)

        {

            e.Stream.Close();

        }

        public static void InputNeeded(object o, StreamEventArgs e)

        {

            if (e.MimeType == "application/xml")

            {

                Uri uri = new Uri(Path.ChangeExtension(e.FileName, "ismc"), UriKind.RelativeOrAbsolute);

                if (!uri.IsFile)

                {

                    throw new InvalidDataException("SmoothStreaming supports only local paths.");

                }

                string localPath = uri.LocalPath;

                e.Stream = new FileStream(localPath, FileMode.Open, FileAccess.Read);

            }

            else

            {

                int num2;

                Debug.WriteLine("Input Event for: " + e.FileName);

                string[] strArray = e.FileName.Split(new char[] { '\\' });

                string[] strArray2 = strArray[strArray.Length - 1].Split(splitarray);

                long num = (factor * int.Parse(strArray2[strArray2.Length - 2], CultureInfo.InvariantCulture)) + int.Parse(strArray2[strArray2.Length - 2], CultureInfo.InvariantCulture);

                string str2 = strArray[strArray.Length - 3];

                string str3 = string.Empty;

                for (num2 = 0; num2 <= (strArray.Length - 4); num2++)

                {

                    str3 = str3 + strArray[num2] + '\\';

                }

                FileStream input = new FileStream(str3 + str2.Substring(0, str2.Length - 6) + "_" + int.Parse(strArray[strArray.Length - 2], CultureInfo.InvariantCulture).ToString("00", CultureInfo.InvariantCulture) + ".ismv", FileMode.Open, FileAccess.Read);

                BinaryReader reader = new BinaryReader(input);

                reader.BaseStream.Seek(-4L, SeekOrigin.End);

                int num3 = IPAddress.NetworkToHostOrder(reader.ReadInt32());

                reader.BaseStream.Seek((long)(-num3 + 0x1c), SeekOrigin.End);

                int num4 = IPAddress.NetworkToHostOrder(reader.ReadInt32());

                long num5 = 0L;

                for (num2 = 0; num2 < num4; num2++)

                {

                    long num6 = IPAddress.NetworkToHostOrder(reader.ReadInt64());

                    num5 = IPAddress.NetworkToHostOrder(reader.ReadInt64());

                    if (num6 == num)

                    {

                        break;

                    }

                    reader.BaseStream.Seek(3L, SeekOrigin.Current);

                }

                reader.BaseStream.Seek(num5 + 0x40L, SeekOrigin.Begin);

                int count = IPAddress.NetworkToHostOrder(reader.ReadInt32());

                reader.ReadInt32();

                byte[] buffer = new byte[count];

                input.Read(buffer, 0, count);

                MemoryStream stream2 = new MemoryStream(buffer);

                e.Stream = stream2;

                reader.Close();

                input.Close();

            }

        }

        public void OutputCompleted(object o, StreamEventArgs e)

        {

            Debug.WriteLine("Output Completed Event for: " + e.FileName);

            if (e.MimeType == "application/xml")

            {

                e.Stream.Close();

            }

            else

            {

                string[] strArray = e.FileName.Split(splitarray);

                int index = int.Parse(strArray[strArray.Length - 4], CultureInfo.InvariantCulture);

                if (this.mp4files[index] == null)

                {

                    this.mp4files[index] = new MP4File(this.GetFileName(index));

                }

                this.mp4files[index].WriteMP4Fragment(this.memoryStream.ToArray(), int.Parse(strArray[strArray.Length - 3], CultureInfo.InvariantCulture) + (factor * int.Parse(strArray[strArray.Length - 2], CultureInfo.InvariantCulture)));

            }

        }

        public void OutputNeeded(object o, StreamEventArgs e)

        {

            Debug.WriteLine("Output Needed Event for: " + e.FileName);

            if (e.MimeType == "application/xml")

            {

                e.Stream = new FileStream(Path.ChangeExtension(this.rootFileName, "ismc"), FileMode.Create);

            }

            else

            {

                this.memoryStream.Position = 0L;

                e.Stream = this.memoryStream;

            }

        }

        private void WriteServerManifest(int maxlevel)

        {

            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(this.rootFileName);

            XNamespace namespace2 = "http://www.w3.org/2001/SMIL20/Language";

            XElement content = new XElement((XName)(namespace2 + "switch"));

            for (int i = 0; i <= maxlevel; i++)

            {

                XElement element2 = new XElement((XName)(namespace2 + "param"), new object[] { new XAttribute("name", "trackID"), new XAttribute("value", "1"), new XAttribute("valuetype", "data") });

                XElement element3 = new XElement((XName)(namespace2 + "param"), new object[] { new XAttribute("name", "trackName"), new XAttribute("value", "tile"), new XAttribute("valuetype", "data") });

                XElement element4 = new XElement((XName)(namespace2 + "video"), new object[] { new XAttribute("src", Path.GetFileName(this.GetFileName(i))), new XAttribute("systemBitrate", i + 100), element2, element3 });

                content.Add(element4);

            }

            XElement element5 = new XElement((XName)(namespace2 + "body"), content);

            XElement element6 = new XElement((XName)(namespace2 + "meta"), new object[] { new XAttribute("name", "clientManifestRelativePath"), new XAttribute("content", fileNameWithoutExtension + ".ismc") });

            XElement element7 = new XElement((XName)(namespace2 + "head"), element6);

            new XElement((XName)(namespace2 + "smil"), new object[] { element7, element5 }).Save(Path.ChangeExtension(this.rootFileName, "ism"));

        }

    }

}