Пример #1
0
        public OutputProcessor(Arguments args)
        {
            if (args.Universes.Length == 0)
                throw new ArgumentException("No universes specified");

            this.receivedData = new ConcurrentQueue<RawDmxData>();

            this.fileTrigger = new ManualResetEvent(false);
            this.universeData = new Dictionary<int, UniverseInfo>();

            switch (args.FileFormat)
            {
                case Arguments.FileFormats.Csv:
                    this.dataWriter = new Common.CsvFileWriter(args.OutputFile);
                    break;

                case Arguments.FileFormats.Binary:
                    this.dataWriter = new Common.BinaryFileWriter(args.OutputFile);
                    break;

                default:
                    throw new ArgumentException("Invalid File Format");
            }

            this.isRunning = true;

            Task.Run(() =>
            {
                while (isRunning)
                {
                    this.fileTrigger.WaitOne();
                    this.fileTrigger.Reset();

                    RawDmxData dmxData;
                    while (this.receivedData.TryDequeue(out dmxData))
                    {
                        bool newData = false;
                        UniverseInfo previousData;
                        if (!this.universeData.TryGetValue(dmxData.Universe, out previousData))
                        {
                            previousData = new UniverseInfo();
                            previousData.Data = new byte[dmxData.Data.Length];
                            this.universeData.Add(dmxData.Universe, previousData);
                            newData = true;
                        }

                        bool modified = !dmxData.Data.SequenceEqual(previousData.Data);
                        if (newData)
                            modified = true;

                        if (previousData.Data.Length != dmxData.Data.Length)
                            previousData.Data = new byte[dmxData.Data.Length];

                        Buffer.BlockCopy(dmxData.Data, 0, previousData.Data, 0, previousData.Data.Length);

                        if (modified)
                        {
                            this.dataWriter.Output(Common.DmxData.CreateFullFrame(
                                millisecond: dmxData.Timestamp,
                                sequence: dmxData.Sequence,
                                universe: dmxData.Universe,
                                data: dmxData.Data));
                        }
                        else
                        {
                            if (previousData.Sequence != dmxData.Sequence)
                                this.dataWriter.Output(Common.DmxData.CreateNoChange(
                                    millisecond: dmxData.Timestamp,
                                    sequence: dmxData.Sequence,
                                    universe: dmxData.Universe));
                        }

                        previousData.Sequence = dmxData.Sequence;
                        this.samplesWritten++;
                    }

                    if ((this.samplesReceived % 100) == 0)
                        Console.WriteLine("Received {0}, written {1} samples", this.samplesReceived, this.samplesWritten);
                }
            });
        }
Пример #2
0
        public void Dispose()
        {
            this.isRunning = false;
            // Trigger
            this.fileTrigger.Set();

            Console.WriteLine("Received {0} samples", this.samplesReceived);

            this.dataWriter.Dispose();
            this.dataWriter = null;
        }