示例#1
0
        public void ProcessBuffer(byte[] buffer)
        {
            byte[] packetBuffer = new byte[188];
            using (MemoryStream tsStream = new MemoryStream(buffer))
            {
                while (tsStream.Position < tsStream.Length)
                {
                    _bytesInLastSecond += 188;
                    tsStream.Read(packetBuffer, 0, 188);
                    TransportStreamPacket tsPacket = PacketParsing.ParsePacket(packetBuffer);

                    if (tsPacket.packetID == 0x60 || tsPacket.packetID == 0x61)
                    {
                        if (_currentFwPackets.ContainsKey(tsPacket.packetID))
                        {
                            if (tsPacket.payload[0] == 0x00 && (tsPacket.payload[1] == 0xB5 || tsPacket.payload[1] == 0xB6))
                            {
                                // We have started a new packet
                                using (BinaryReaderEndian packetReader = new BinaryReaderEndian(_currentFwPackets[tsPacket.packetID], false))
                                {
                                    packetReader.DontDispose = true;
                                    packetReader.BaseStream.Seek(0, SeekOrigin.Begin);

                                    FwPacket fwPacket;
                                    try
                                    {
                                        fwPacket = ProcessNextFwPacket(packetReader);
                                    }
                                    catch (EndOfStreamException)
                                    {
                                        // Probably a better way of doing this! (When 0x00 0xB5 exists at the beginning of a packet naturaly)
                                        _currentFwPackets[tsPacket.packetID].Write(tsPacket.payload, 0, tsPacket.payload.Length);
                                        continue;
                                    }

                                    string fwName = string.Format("{0:X2}-{1:X2}-{2:X2}", fwPacket.VendorId, fwPacket.ModelId, fwPacket.FirmwareVersion);

                                    lock (CurrentFiles)
                                    {
                                        CurrentFiles[tsPacket.packetID] = string.Format("{0:X2}{1:X2}-r{2}", fwPacket.VendorId, fwPacket.ModelId, fwPacket.FirmwareVersion);
                                    }

                                    if (fwPacket.SectionType == 1 && !CompletedFiles.ContainsKey(fwName))
                                    {
                                        if (!InProgressFiles.ContainsKey(fwName))
                                        {
                                            InProgressFiles.Add(fwName, new FirmwareFile(fwPacket, _extractFolder));
                                            InProgressFileList.Add(InProgressFiles[fwName]);
                                        }
                                        else
                                        {
                                            InProgressFiles[fwName].AddPacket(fwPacket);
                                        }

                                        if (InProgressFiles[fwName].isComplete)
                                        {
                                            _completedListHasChanged = true;
                                            CompletedFiles.Add(fwName, InProgressFiles[fwName]);
                                            CompletedFileList.Add(InProgressFiles[fwName]);
                                            InProgressFileList.Remove(InProgressFiles[fwName]);
                                            InProgressFiles.Remove(fwName);
                                        }
                                    }
                                }

                                _currentFwPackets[tsPacket.packetID].Close();
                                _currentFwPackets[tsPacket.packetID] = new MemoryStream();
                            }

                            _currentFwPackets[tsPacket.packetID].Write(tsPacket.payload, 0, tsPacket.payload.Length);
                        }
                        else if (tsPacket.payload[0] == 0x00 && (tsPacket.payload[1] == 0xB5 || tsPacket.payload[1] == 0xB6))
                        {
                            _currentFwPackets.Add(tsPacket.packetID, new MemoryStream());
                            _currentFwPackets[tsPacket.packetID].Write(tsPacket.payload, 0, tsPacket.payload.Length);
                        }
                    }
                }
            }
        }
示例#2
0
        private void buttonCapture_Click(object sender, RoutedEventArgs e)
        {
            _extractFolder = txtTsLocation.Text;

            if (Directory.Exists(_extractFolder))
            {
                if (Properties.Settings.Default.ExtractDirectory != _extractFolder)
                {
                    Properties.Settings.Default.ExtractDirectory = _extractFolder;
                    Properties.Settings.Default.Save();
                }

                txtTsLocation.IsEnabled = false;
                buttonBrowse.IsEnabled  = false;

                // List already downloaded items
                DirectoryInfo extractDir = new DirectoryInfo(_extractFolder);

                foreach (DirectoryInfo fwFolder in extractDir.EnumerateDirectories())
                {
                    FirmwareFile fwFile = new FirmwareFile(fwFolder.FullName);

                    CompletedFiles.Add(string.Format("{0:X2}-{1:X2}-{2:X2}", fwFile.VendorId, fwFile.ModelId, fwFile.VersionId), fwFile);
                    CompletedFileList.Add(fwFile);
                }

                timer.Interval = new TimeSpan(0, 0, 1);
                timer.Tick    += new EventHandler(timer_Tick);
                timer.Start();

                try
                {
                    // Start BDA Capture
                    int hr = 0;
                    IDVBSTuningSpace tuningSpace;

                    tuningSpace = (IDVBSTuningSpace) new DVBSTuningSpace();
                    hr          = tuningSpace.put_UniqueName("DVBS TuningSpace");
                    hr          = tuningSpace.put_FriendlyName("DVBS TuningSpace");
                    hr          = tuningSpace.put__NetworkType(typeof(DVBSNetworkProvider).GUID);
                    hr          = tuningSpace.put_SystemType(DVBSystemType.Satellite);
                    hr          = tuningSpace.put_LowOscillator(9750000);
                    hr          = tuningSpace.put_HighOscillator(10600000);

                    ITuneRequest tr = null;

                    hr = tuningSpace.CreateTuneRequest(out tr);
                    DsError.ThrowExceptionForHR(hr);

                    IDVBTuneRequest tuneRequest = (IDVBTuneRequest)tr;

                    hr = tuneRequest.put_ONID(2);
                    hr = tuneRequest.put_TSID(2004);
                    hr = tuneRequest.put_SID(4190);

                    IDVBSLocator locator = (IDVBSLocator) new DVBSLocator();
                    hr = locator.put_CarrierFrequency(11778000);
                    hr = locator.put_SymbolRate(27500000);
                    hr = locator.put_Modulation(ModulationType.ModQpsk);
                    hr = (locator as IDVBSLocator).put_SignalPolarisation(Polarisation.LinearV);
                    hr = (locator as IDVBSLocator).put_InnerFEC(FECMethod.Viterbi);
                    hr = (locator as IDVBSLocator).put_InnerFECRate(BinaryConvolutionCodeRate.Rate2_3);
                    hr = (locator as IDVBSLocator).put_OuterFEC(FECMethod.Viterbi);
                    hr = (locator as IDVBSLocator).put_OuterFECRate(BinaryConvolutionCodeRate.Rate2_3);

                    hr = tr.put_Locator(locator as ILocator);
                    Marshal.ReleaseComObject(locator);

                    this.bdaGraphBuilder = new BDAGraphBuilder();
                    this.bdaGraphBuilder.BuildGraph(tuningSpace);
                    this.bdaGraphBuilder.SubmitTuneRequest(tr);

                    // We have to do this to make it actually tune!
                    this.bdaGraphBuilder.RunGraph();
                    this.bdaGraphBuilder.StopGraph();

                    TsGrabber grabber = new TsGrabber();
                    grabber.Callback = new TsGrabber.ProcessBufferDelegate(ProcessBuffer);

                    this.bdaGraphBuilder.SetUpForTs(grabber, 1);

                    this.bdaGraphBuilder.RunGraph();

                    this.buttonCapture.IsEnabled = false;
                }
                catch (Exception ex)
                {
                    MessageBox.Show(string.Format("Error connecting to DVB-S:\n{0}", ex), "Connection error", MessageBoxButton.OK, MessageBoxImage.Error);
                    Close();
                }
            }
            else
            {
                MessageBox.Show("Cannot find extract directory specified!");
            }
        }
示例#3
0
        public AppModel()
        {
            this.listener = new Lazy <AppModelTraceListener>(() => Trace.Listeners.OfType <AppModelTraceListener>().FirstOrDefault());

            this.uMonitor = new UTorrentMonitor(Application.Current.Dispatcher);
            this.uMonitor.ReadyTorrents += OnTorrentReady;

            this.WorkQueue      = new BlockingCollection <EpisodeFile>();
            this.RunningFiles   = new ObservableCollection <EpisodeFile>();
            this.Files          = new ObservableCollection <EpisodeFile>();
            this.CompletedFiles = new ObservableCollection <EpisodeFile>();

            this.Files.CollectionChanged += (s, e) =>
            {
                switch (e.Action)
                {
                case NotifyCollectionChangedAction.Remove:
                    foreach (var item in e.OldItems.Cast <EpisodeFile>())
                    {
                        item.Cancel();
                    }
                    break;

                case NotifyCollectionChangedAction.Reset:
                    foreach (var item in this.Files)
                    {
                        item.Cancel();
                    }
                    break;
                }

                OnPropertyChanged("IsFileSetEmpty", "Status");
            };

            this.RunningFiles.CollectionChanged += (s, e) =>
            {
                if (e.Action == NotifyCollectionChangedAction.Add)
                {
                    foreach (var item in e.NewItems.Cast <EpisodeFile>())
                    {
                        item.Status = "Waiting ...";
                        this.WorkQueue.Add(item);
                    }
                }
            };

            Task.Factory.StartNew(() =>
            {
                foreach (var item in WorkQueue.GetConsumingEnumerable())
                {
                    var file = item;

                    // do the processing
                    file.Status = "Processing ...";

                    var errors = new List <string>();


                    // first do copy
                    foreach (
                        var action in
                        file.Actions.Where(a => a.Command == EpisodeFileActionCommand.Copy && a.IsEnabled))
                    {
                        try
                        {
                            item.Status = action.TargetCommand;
                            var dir     = Path.GetDirectoryName(action.TargetPath);
                            if ((dir != null) && (!Directory.Exists(dir)))
                            {
                                Directory.CreateDirectory(dir);
                            }

                            var fo = new InteropSHFileOperation()
                            {
                                pFrom  = item.FilePath,
                                pTo    = action.TargetPath,
                                wFunc  = InteropSHFileOperation.FO_Func.FO_COPY,
                                fFlags = new InteropSHFileOperation.FILEOP_FLAGS()
                                {
                                    FOF_RENAMEONCOLLISION = true
                                }
                            };
                            fo.Execute();

                            //File.Copy(item.FilePath, action.TargetPath, false);
                            action.IsEnabled = false;
                        }
                        catch (Exception ex)
                        {
                            errors.Add(ex.Message);
                        }
                    }

                    var renameAction =
                        file.Actions.FirstOrDefault(a => a.Command == EpisodeFileActionCommand.Move && a.IsEnabled);


                    if (errors.Count == 0 && renameAction != null)
                    {
                        try
                        {
                            file.Status = renameAction.TargetCommand;
                            var dir     = Path.GetDirectoryName(renameAction.TargetPath);
                            if ((dir != null) && (!Directory.Exists(dir)))
                            {
                                Directory.CreateDirectory(dir);
                            }

                            var fo = new InteropSHFileOperation()
                            {
                                pFrom  = item.FilePath,
                                pTo    = renameAction.TargetPath,
                                wFunc  = InteropSHFileOperation.FO_Func.FO_MOVE,
                                fFlags = new InteropSHFileOperation.FILEOP_FLAGS()
                                {
                                    FOF_RENAMEONCOLLISION = true
                                }
                            };
                            fo.Execute();
                            renameAction.IsEnabled = false;
                        }
                        catch (Exception ex)
                        {
                            errors.Add(ex.Message);
                        }
                    }

                    if (errors.Count == 0)
                    {
                        file.Status = "Done";
                        try
                        {
                            //detect if this directory contains any more video files or files bigger then 1MB
                            // if not, delete it
                            var dir = Path.GetDirectoryName(file.FilePath);
                            if (!Directory.EnumerateFiles(dir, "*.*", SearchOption.AllDirectories).Select(fl => new FileInfo(fl)).Any(fl =>
                                                                                                                                      ((fl.Length > 1024 * 1024) || Settings.GetVideoExtensions().Any(ex => string.Equals(fl.Extension, ex, StringComparison.CurrentCultureIgnoreCase)))
                                                                                                                                      ))
                            {
                                // delete directory
                                Directory.Delete(dir, true);
                            }
                        }
                        catch
                        {
                        }


                        Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            file.Errors.Clear();
                            RunningFiles.Remove(file);
                            CompletedFiles.Add(file);
                        }));
                    }
                    else
                    {
                        file.Status = "Waiting for retry";

                        Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            file.Errors.Clear();
                            foreach (var err in errors)
                            {
                                file.Errors.Add(err);
                            }
                        }));

                        file.RetryTimer = new DispatcherTimer(TimeSpan.FromMinutes(5), DispatcherPriority.Normal,
                                                              (s, e) =>
                        {
                            file.Errors.Clear();


                            file.RetryTimer.Stop();

                            file.Status = "Pending ...";
                            this.WorkQueue.Add(file);
                        },
                                                              Application.Current.Dispatcher);
                    }
                }
            });

            this.RunWatcher();
            //this.Watcher.EnableRaisingEvents = this.Settings.RunMonitor;
            this.Settings.SettingsSaving += Settings_SettingsSaving;
        }