示例#1
0
        /// <summary>
        /// Entfernt den Videotext Teildatenstrom (PID) aus einer Anforderung.
        /// </summary>
        /// <param name="streams">Die gewünschte Anforderung.</param>
        /// <param name="needed">Die Anzahl der benötigten Verbraucher, die geeignet
        /// korrigiert wird.</param>
        /// <param name="report">Protokolliert die vorgenommene Veränderung.</param>
        /// <returns>Gesetzt, wenn eine Änderung vorgenommen wurde.</returns>
        private static bool RemoveVideoText(this StreamSelection streams, ref int needed, Action <string, int> report)
        {
            // Not necessary
            if (needed < 1)
            {
                return(false);
            }

            // Not possible
            if (!streams.Videotext)
            {
                return(false);
            }

            // Report
            if (null != report)
            {
                report("VideoText", 1);
            }

            // Remove
            streams.Videotext = false;

            // Correct counter
            --needed;

            // Report
            return(true);
        }
示例#2
0
        /// <summary>
        /// Entfernt die Untertitel Teildatenströme (PID) aus einer Anforderung.
        /// </summary>
        /// <param name="streams">Die gewünschte Anforderung.</param>
        /// <param name="needed">Die Anzahl der benötigten Verbraucher, die geeignet
        /// korrigiert wird.</param>
        /// <param name="report">Protokolliert die vorgenommene Veränderung.</param>
        /// <returns>Gesetzt, wenn eine Änderung vorgenommen wurde.</returns>
        private static bool RemoveSubTitles(this StreamSelection streams, ref int needed, Action <string, int> report)
        {
            // Not necessary
            if (needed < 1)
            {
                return(false);
            }

            // Get the count
            int count = streams.SubTitles.GetLanguageCount();

            // Not possible
            if (count < 1)
            {
                return(false);
            }

            // Report
            if (null != report)
            {
                report("SubTitles", count);
            }

            // Correct
            needed = Math.Max(0, needed - count);

            // Wipe out
            streams.SubTitles.LanguageMode = LanguageModes.Selection;
            streams.SubTitles.Languages.Clear();

            // Report
            return(true);
        }
示例#3
0
        /// <summary>
        /// Prüft, ob eine Datenstromauswahl zulässig ist.
        /// </summary>
        /// <param name="streams">Die Auswahl der Datenströme.</param>
        /// <returns>Gesetzt, wenn die Auswahl gültig ist - und mindestens eine Tonspur enthält.</returns>
        public static bool Validate(this StreamSelection streams)
        {
            // Not possible
            if (streams == null)
            {
                return(false);
            }

            // Test for wildcards - may fail at runtime!
            if (streams.MP2Tracks.LanguageMode != LanguageModes.Selection)
            {
                return(true);
            }
            if (streams.AC3Tracks.LanguageMode != LanguageModes.Selection)
            {
                return(true);
            }

            // Test for language selection - may fail at runtime but at least we tried
            if (streams.MP2Tracks.Languages.Count > 0)
            {
                return(true);
            }
            if (streams.AC3Tracks.Languages.Count > 0)
            {
                return(true);
            }

            // Will definitly fail
            return(false);
        }
        public void ReportPCR()
        {
            // Prepare receiption
            var station = GetDefaultStation();

            // Prepare selection
            var selection = new StreamSelection { Videotext = false, ProgramGuide = false };

            // Add all
            selection.AC3Tracks.LanguageMode = LanguageModes.Selection;
            selection.SubTitles.LanguageMode = LanguageModes.Selection;
            selection.MP2Tracks.LanguageMode = LanguageModes.Primary;

            // Get a file name
            var tempFile = GetUniqueFile();

            // Collected PCR data
            var pcrData = new Dictionary<long, TimeSpan>();

            // Minium
            TimeSpan? minPCR = null;

            // Open it
            using (var streamManager = new SourceStreamsManager( Device, Profile, station.Source, selection ))
            {
                // Attach PCR handler
                streamManager.OnWritingPCR += ( path, position, packet ) =>
                    {
                        // Test
                        Assert.AreEqual( tempFile.FullName, path );

                        // Get the PCR
                        TimeSpan pcr = Manager.GetPCR( packet );

                        // Remember minimum
                        if (!minPCR.HasValue)
                            minPCR = pcr;

                        // Remember
                        pcrData.Add( position, pcr );
                    };

                // Send to file
                streamManager.CreateStream( tempFile.FullName, station );

                // Process
                Thread.Sleep( 10000 );

                // Done
                streamManager.CloseStream();
            }

            // Must have some
            Assert.IsTrue( minPCR.HasValue );

            // Report
            foreach (var pair in pcrData.OrderBy( p => p.Key ))
                Console.WriteLine( "{0:000000000}\t{1}\t{2}", pair.Key, pair.Value, pair.Value - minPCR.Value );
        }
示例#5
0
        private void SetStreams(string sName)
        {
            // First find the mapping between the output name and
            // the stream number
            IWMProfile pProfile = m_pReader as IWMProfile;

            int iCount;

            pProfile.GetStreamCount(out iCount);
            short[]           sss = new short[iCount];
            StreamSelection[] ss  = new StreamSelection[iCount];

            StringBuilder sSName;

            for (short j = 0; j < iCount; j++)
            {
                IWMStreamConfig pConfig;
                pProfile.GetStream(j, out pConfig);

                try
                {
                    pConfig.GetStreamNumber(out sss[j]);

                    short iSName = 0;
                    sSName = null;
                    pConfig.GetConnectionName(sSName, ref iSName);
                    sSName = new StringBuilder(iSName);
                    pConfig.GetConnectionName(sSName, ref iSName);
                }
                finally
                {
                    Marshal.ReleaseComObject(pConfig);
                }

                // Turn the stream on or off depending on whether
                // this is the one that matches the output we're
                // looking for
                if (sSName.ToString() == sName)
                {
                    ss[j] = StreamSelection.On;
                }
                else
                {
                    ss[j] = StreamSelection.Off;
                }
            }

            // Use the array we've built to specify the streams we want
            IWMReaderAdvanced ra = m_pReader as IWMReaderAdvanced;

            ra.SetStreamsSelected((short)iCount, sss, ss);

            // Learn the maximum sample size that will be send to OnSample
            ra.GetMaxOutputSampleSize(m_dwAudioOutputNum, out m_MaxSampleSize);

            // Have the Samples allocated using IWMReaderCallbackAdvanced::AllocateForOutput
            ra.SetAllocateForOutput(m_dwAudioOutputNum, true);
        }
示例#6
0
 /// <summary>
 /// Entfernt eine alternative AC3 Tonspuren aus einer Anforderung.
 /// </summary>
 /// <param name="streams">Die gewünschte Anforderung.</param>
 /// <param name="needed">Die Anzahl der benötigten Verbraucher, die geeignet
 /// korrigiert wird.</param>
 /// <param name="report">Protokolliert die vorgenommene Veränderung.</param>
 /// <returns>Gesetzt, wenn eine Änderung vorgenommen wurde.</returns>
 private static bool RemoveAlternateAC3Audio(this StreamSelection streams, ref int needed, Action <string, int> report)
 {
     // Use helper
     return(streams.AC3Tracks.RemoveAlternateLanguages(ref needed, l => { if (null != report)
                                                                          {
                                                                              report("AC3 " + l, 1);
                                                                          }
                                                       }));
 }
示例#7
0
        /// <summary>
        /// Erzeugt eine neue Beschreibung.
        /// </summary>
        /// <param name="uniqueIdentifier">Die eindeutige Kennung dieses Datenstroms.</param>
        /// <param name="manager">Die Verwaltung des Empfangs.</param>
        /// <param name="targetPath">Ein optionaler Dateiname zur Ablage der empfangenen Daten.</param>
        /// <param name="originalSelection">Die ursprünglich angeforderte Konfiguration der Aufzeichnung.</param>
        /// <exception cref="ArgumentNullException">Es wurde keine Verwaltung angegeben</exception>
        public ActiveStream( Guid uniqueIdentifier, SourceStreamsManager manager, StreamSelection originalSelection, string targetPath )
        {
            // Validate
            if (manager == null)
                throw new ArgumentNullException( "manager" );

            // Remember
            SourceKey = new SourceIdenfierWithKey( uniqueIdentifier, manager.Source );
            RequestedStreams = originalSelection.Clone();
            TargetPath = targetPath;
            Manager = manager;
        }
        /// <summary>
        /// Erzeugt eine neue Beschreibung.
        /// </summary>
        /// <param name="uniqueIdentifier">Die eindeutige Kennung dieses Datenstroms.</param>
        /// <param name="manager">Die Verwaltung des Empfangs.</param>
        /// <param name="targetPath">Ein optionaler Dateiname zur Ablage der empfangenen Daten.</param>
        /// <param name="originalSelection">Die ursprünglich angeforderte Konfiguration der Aufzeichnung.</param>
        /// <exception cref="ArgumentNullException">Es wurde keine Verwaltung angegeben</exception>
        public ActiveStream(Guid uniqueIdentifier, SourceStreamsManager manager, StreamSelection originalSelection, string targetPath)
        {
            // Validate
            if (manager == null)
            {
                throw new ArgumentNullException("manager");
            }

            // Remember
            SourceKey        = new SourceIdenfierWithKey(uniqueIdentifier, manager.Source);
            RequestedStreams = originalSelection.Clone();
            TargetPath       = targetPath;
            Manager          = manager;
        }
示例#9
0
        /// <summary>
        /// Legt fest, ob DVB Untertitel aufgezeichnet werden sollen.
        /// </summary>
        /// <param name="streams">Die Konfiguration der zu verwendenden Datenströme.</param>
        /// <param name="set">Gesetzt, wenn die Datenspuren aktiviert werden sollen.</param>
        public static void SetUsesSubtitles(this StreamSelection streams, bool set)
        {
            // Reset language list
            streams.SubTitles.Languages.Clear();

            // Check mode
            if (set)
            {
                streams.SubTitles.LanguageMode = LanguageModes.All;
            }
            else
            {
                streams.SubTitles.LanguageMode = LanguageModes.Selection;
            }
        }
示例#10
0
 /// <summary>
 /// Prüft, ob eine Datenstromkonfiguration DVB Untertitel nicht
 /// grundsätzlich ausschließt.
 /// </summary>
 /// <param name="streams">Die Datenstromkonfiguration.</param>
 /// <returns>Gesetzt, wenn die DVB Untertitel nicht grundsätzlich deaktiviert sind.</returns>
 public static bool GetUsesSubtitles(this StreamSelection streams)
 {
     // Check mode
     if (streams == null)
     {
         return(false);
     }
     else if (streams.SubTitles.LanguageMode != LanguageModes.Selection)
     {
         return(true);
     }
     else
     {
         return(streams.SubTitles.Languages.Count > 0);
     }
 }
示例#11
0
 /// <summary>
 /// Prüft, ob eine Datenstromkonfiguration eine Dolby Digital Tonspur nicht
 /// grundsätzlich ausschließt.
 /// </summary>
 /// <param name="streams">Die Datenstromkonfiguration.</param>
 /// <returns>Gesetzt, wenn die AC3 Tonspur nicht grundsätzlich deaktiviert ist.</returns>
 public static bool GetUsesDolbyAudio(this StreamSelection streams)
 {
     // Check mode
     if (streams == null)
     {
         return(false);
     }
     else if (streams.AC3Tracks.LanguageMode != LanguageModes.Selection)
     {
         return(true);
     }
     else
     {
         return(streams.AC3Tracks.Languages.Count > 0);
     }
 }
        public void SplitFiles()
        {
            // Prepare receiption
            var station = GetDefaultStation();

            // Prepare selection
            var selection = new StreamSelection {
                Videotext = true, ProgramGuide = false
            };

            // Add all
            selection.AC3Tracks.LanguageMode = LanguageModes.All;
            selection.MP2Tracks.LanguageMode = LanguageModes.All;
            selection.SubTitles.LanguageMode = LanguageModes.All;

            // Get a file name
            var tempFile = GetUniqueFile();

            // Get the file name pattern
            var filePattern = Path.Combine(tempFile.DirectoryName, Path.GetFileNameWithoutExtension(tempFile.Name));

            // Open it
            using (var streamManager = new SourceStreamsManager(Device, Profile, station.Source, selection))
            {
                // Send to file
                streamManager.CreateStream(string.Format(FileNamePattern, filePattern, 0), station);

                // Process
                for (int i = 0; i++ < 3; Thread.Sleep(10000))
                {
                    // Delay - first and last will have only half the size
                    Thread.Sleep(10000);

                    // New file
                    Assert.IsTrue(streamManager.SplitFile(string.Format(FileNamePattern, filePattern, i)));
                }

                // Done
                streamManager.CloseStream();

                // Report
                foreach (var file in streamManager.AllFiles)
                {
                    Console.WriteLine(file);
                }
            }
        }
示例#13
0
        /// <summary>
        /// Fügt eine Quelle zur Aufzeichnung hinzu.
        /// </summary>
        /// <param name="source">Die gewünschte Quelle.</param>
        /// <param name="streams">Die Informationen zu den einzuschliessenden
        /// Teildatenströmen (PID).</param>
        /// <exception cref="ArgumentNullException">Ein Parameter wurde nicht angegeben.</exception>
        public void Add(SourceSelection source, StreamSelection streams)
        {
            // Validate
            if (null == source)
            {
                throw new ArgumentNullException("source");
            }
            if (null == streams)
            {
                throw new ArgumentNullException("streams");
            }

            // Remember
            m_Sources.Add(new SelectionInfo {
                Source = source, OriginalStreams = streams.Clone()
            });
        }
示例#14
0
        /// <summary>
        /// Ermittelt eine möglicherweise eingeschränkte Datenstromauswahl.
        /// </summary>
        /// <param name="manager">Die Quelle, um die es geht.</param>
        /// <returns>Eine geeignete Auswahl.</returns>
        private StreamSelection GetOptimizedStreams(SourceStreamsManager manager)
        {
            // Not possible
            if (null == CurrentSelection)
            {
                return(null);
            }

            // What we want to record
            StreamSelection selection = new StreamSelection();

            // Put it on
            selection.AC3Tracks.LanguageMode = LanguageModes.All;
            selection.MP2Tracks.LanguageMode = LanguageModes.All;
            selection.SubTitles.LanguageMode = LanguageModes.All;
            selection.ProgramGuide           = true;
            selection.Videotext = true;

            // See if we are working on a limited device
            if (!Device.HasConsumerRestriction)
            {
                return(selection);
            }

            // Stop picture for a moment
            Device.SetConsumerState(VideoId, false);
            Device.SetConsumerState(AudioId, false);
            Device.SetConsumerState(TextId, false);

            // Require restart
            m_NeedRestart = true;

            // Create a brand new optimizer
            StreamSelectionOptimizer localOpt = new StreamSelectionOptimizer();

            // Add the one stream
            localOpt.Add(CurrentSelection, selection);

            // Run the optimization
            localOpt.Optimize();

            // Report result
            return(localOpt.GetStreams(0));
        }
        private void TestSelected()
        {
            int i;

            m_read.GetOutputCount(out i);

            short[]           pn  = new short[2];
            StreamSelection[] ps1 = new StreamSelection[2];
            StreamSelection[] ps2 = new StreamSelection[2];

            ps1[0] = StreamSelection.CleanPointOnly;
            ps1[1] = StreamSelection.On;

            pn[0] = 1;
            pn[1] = 2;

            m_read.SetStreamsSelected(2, pn, ps1);

            m_read.GetStreamSelected(1, out ps2[0]);
            m_read.GetStreamSelected(2, out ps2[1]);
        }
示例#16
0
        private void TestStreamsSelected()
        {
            short[]           psn = new short[2];
            StreamSelection[] pss = new StreamSelection[2];

            psn[0] = 1;
            psn[1] = 2;

            pss[0] = StreamSelection.CleanPointOnly;
            pss[1] = StreamSelection.Off;

            m_read.SetStreamsSelected(2, psn, pss);

            StreamSelection ps;

            m_read.GetStreamSelected(1, out ps);
            Debug.Assert(ps == StreamSelection.CleanPointOnly);

            m_read.GetStreamSelected(2, out ps);
            Debug.Assert(ps == StreamSelection.Off);
        }
 /// <summary>Ctor. </summary>
 public ConfigurationEngineDefaults()
 {
     ThreadingConfig          = new Threading();
     ViewResourcesConfig      = new ViewResources();
     EventMetaConfig          = new EventMeta();
     LoggingConfig            = new Logging();
     VariablesConfig          = new Variables();
     StreamSelectionConfig    = new StreamSelection();
     TimeSourceConfig         = new TimeSource();
     MetricsReportingConfig   = new ConfigurationMetricsReporting();
     LanguageConfig           = new Language();
     ExpressionConfig         = new Expression();
     ExecutionConfig          = new Execution();
     ExceptionHandlingConfig  = new ExceptionHandling();
     ConditionHandlingConfig  = new ConditionHandling();
     AlternativeContextConfig = new AlternativeContext();
     ClusterConfig            = new Cluster();
     PatternsConfig           = new Patterns();
     MatchRecognizeConfig     = new MatchRecognize();
     ScriptsConfig            = new Scripts();
 }
示例#18
0
        /// <summary>
        /// Entfernt eine alle MP2 Tonspuren aus einer Anforderung, wenn mindestens eine AC3
        /// Tonspur vorhanden ist.
        /// </summary>
        /// <param name="streams">Die gewünschte Anforderung.</param>
        /// <param name="needed">Die Anzahl der benötigten Verbraucher, die geeignet
        /// korrigiert wird.</param>
        /// <param name="report">Protokolliert die vorgenommene Veränderung.</param>
        /// <returns>Gesetzt, wenn eine Änderung vorgenommen wurde.</returns>
        private static bool RemoveMP2AudioIfAC3Present(this StreamSelection streams, ref int needed, Action <string, int> report)
        {
            // Not need
            if (needed < 1)
            {
                return(false);
            }

            // Get the count
            int count = streams.MP2Tracks.GetLanguageCount();

            // Not possible
            if (count < 1)
            {
                return(false);
            }

            // Not possible
            if (streams.AC3Tracks.GetLanguageCount() < 1)
            {
                return(false);
            }

            // Report
            if (null != report)
            {
                report("MP2", count);
            }

            // Correct
            needed = Math.Max(0, needed - count);

            // Wipe out
            streams.MP2Tracks.LanguageMode = LanguageModes.Selection;
            streams.MP2Tracks.Languages.Clear();

            // Report
            return(true);
        }
示例#19
0
        private void ChangeSelected(IWMReaderAdvanced ra)
        {
            short[] ss = new short[2];
            ss[0] = 1;
            ss[1] = 2;

            StreamSelection[] sss = new StreamSelection[2];

            if (m_loop == 0)
            {
                sss[0] = StreamSelection.Off;
                sss[1] = StreamSelection.On;
                m_loop = 1;
            }
            else
            {
                sss[1] = StreamSelection.Off;
                sss[0] = StreamSelection.On;
                m_loop = 0;
            }
            ra.SetStreamsSelected(2, ss, sss);
        }
示例#20
0
        /// <summary>
        /// Legt fest, ob die Dolby Digital Tonspur aufgezeichnet werden soll.
        /// </summary>
        /// <param name="streams">Die Konfiguration der zu verwendenden Datenströme.</param>
        /// <param name="set">Gesetzt, wenn die Datenspur aktiviert werden soll.</param>
        public static void SetUsesDolbyAudio(this StreamSelection streams, bool set)
        {
            // Reset language list
            streams.AC3Tracks.Languages.Clear();

            // Check mode
            if (set)
            {
                if (streams.MP2Tracks.LanguageMode == LanguageModes.Selection)
                {
                    streams.AC3Tracks.LanguageMode = LanguageModes.Primary;
                }
                else
                {
                    streams.AC3Tracks.LanguageMode = streams.MP2Tracks.LanguageMode;
                }
            }
            else
            {
                streams.AC3Tracks.LanguageMode = LanguageModes.Selection;
            }
        }
示例#21
0
        /// <summary>
        /// Legt fest, ob alle Tonspuren aufgezeichnet werden sollen.
        /// </summary>
        /// <param name="streams">Die Konfiguration der zu verwendenden Datenströme.</param>
        /// <param name="set">Gesetzt, wenn die Datenspuren aktiviert werden sollen.</param>
        public static void SetUsesAllAudio(this StreamSelection streams, bool set)
        {
            // Clear all
            streams.MP2Tracks.Languages.Clear();
            streams.AC3Tracks.Languages.Clear();

            // Check mode
            if (set)
            {
                streams.MP2Tracks.LanguageMode = LanguageModes.All;
            }
            else
            {
                streams.MP2Tracks.LanguageMode = LanguageModes.Primary;
            }

            // Forward
            if (streams.AC3Tracks.LanguageMode != LanguageModes.Selection)
            {
                streams.AC3Tracks.LanguageMode = streams.MP2Tracks.LanguageMode;
            }
        }
        /// <summary>
        /// Fügt eine Quelle zur Aufzeichnung hinzu.
        /// </summary>
        /// <param name="source">Die gewünschte Quelle.</param>
        /// <param name="streams">Die Informationen zu den einzuschliessenden
        /// Teildatenströmen (PID).</param>
        /// <exception cref="ArgumentNullException">Ein Parameter wurde nicht angegeben.</exception>
        public void Add( SourceSelection source, StreamSelection streams )
        {
            // Validate
            if (null == source)
                throw new ArgumentNullException( "source" );
            if (null == streams)
                throw new ArgumentNullException( "streams" );

            // Remember
            m_Sources.Add( new SelectionInfo { Source = source, OriginalStreams = streams.Clone() } );
        }
        public void ReportPCR()
        {
            // Prepare receiption
            var station = GetDefaultStation();

            // Prepare selection
            var selection = new StreamSelection {
                Videotext = false, ProgramGuide = false
            };

            // Add all
            selection.AC3Tracks.LanguageMode = LanguageModes.Selection;
            selection.SubTitles.LanguageMode = LanguageModes.Selection;
            selection.MP2Tracks.LanguageMode = LanguageModes.Primary;

            // Get a file name
            var tempFile = GetUniqueFile();

            // Collected PCR data
            var pcrData = new Dictionary <long, TimeSpan>();

            // Minium
            TimeSpan?minPCR = null;

            // Open it
            using (var streamManager = new SourceStreamsManager(Device, Profile, station.Source, selection))
            {
                // Attach PCR handler
                streamManager.OnWritingPCR += (path, position, packet) =>
                {
                    // Test
                    Assert.AreEqual(tempFile.FullName, path);

                    // Get the PCR
                    TimeSpan pcr = Manager.GetPCR(packet);

                    // Remember minimum
                    if (!minPCR.HasValue)
                    {
                        minPCR = pcr;
                    }

                    // Remember
                    pcrData.Add(position, pcr);
                };

                // Send to file
                streamManager.CreateStream(tempFile.FullName, station);

                // Process
                Thread.Sleep(10000);

                // Done
                streamManager.CloseStream();
            }

            // Must have some
            Assert.IsTrue(minPCR.HasValue);

            // Report
            foreach (var pair in pcrData.OrderBy(p => p.Key))
            {
                Console.WriteLine("{0:000000000}\t{1}\t{2}", pair.Key, pair.Value, pair.Value - minPCR.Value);
            }
        }
示例#24
0
 /// <summary>
 /// Prüft, ob eine Datenstromkonfiguration alle Tonspuren einschließt.
 /// </summary>
 /// <param name="streams">Die Datenstromkonfiguration.</param>
 /// <returns>Gesetzt, wenn alle Tonspuren aufgezeichnet werden sollen.</returns>
 public static bool GetUsesAllAudio(this StreamSelection streams) => (streams != null) && (streams.MP2Tracks.LanguageMode == LanguageModes.All);
        /// <summary>
        /// Aktiviert eine einzelne Quelle für den <i>Zapping Modus</i>.
        /// </summary>
        /// <param name="source">Die gewünschte Quelle.</param>
        /// <param name="target">Die Netzwerkadresse, an die alle Daten versendet werden sollen.</param>
        protected override void OnSetZappingSource(SourceSelection source, string target)
        {
            // Prepare operation
            Start(device =>
            {
                // The next stream identifier to use
                short nextStreamIdentifier = 0;
                if (Streams.Count > 0)
                {
                    nextStreamIdentifier = Streams.Values.First().Manager.NextStreamIdentifier;
                }

                // Activate the source group - will terminate all active streams
                SelectGroup(device, source);

                // Create optimizer and stream selector
                var optimizer = new StreamSelectionOptimizer();
                var streams   =
                    new StreamSelection
                {
                    AC3Tracks    = { LanguageMode = LanguageModes.All },
                    MP2Tracks    = { LanguageMode = LanguageModes.All },
                    SubTitles    = { LanguageMode = LanguageModes.All },
                    ProgramGuide = true,
                    Videotext    = true,
                };

                // Prepare to optimize
                optimizer.Add(source, streams);

                // See how many we are allowed to start
                optimizer.Optimize();

                // Create
                var stream = new ActiveStream(Guid.Empty, source.Open(optimizer.GetStreams(0)), streams, null);
                try
                {
                    // Configure streaming target
                    stream.Manager.StreamingTarget = target;

                    // Attach next stream identifier
                    stream.Manager.NextStreamIdentifier = nextStreamIdentifier;

                    // See if we have to connect an optimizer for restarts
                    if (device.HasConsumerRestriction)
                    {
                        stream.EnableOptimizer(source);
                    }

                    // Try to start
                    stream.Refresh(m_RetestWatchDogInterval);

                    // Load
                    Streams.Add(stream.SourceKey, stream);
                }
                catch
                {
                    // Cleanup
                    stream.Dispose();

                    // Forward
                    throw;
                }

                // Report state
                return(CreateState(device));
            });
        }
示例#26
0
 /// <summary>
 /// Prüft, ob eine Datenstromkonfiguration auch den Videotext umfasst.
 /// </summary>
 /// <param name="streams">Die Datenstromkonfiguration.</param>
 /// <returns>Gesetzt, wenn der Videotext aufgezeichnet werden soll.</returns>
 public static bool GetUsesVideotext(this StreamSelection streams) => (streams != null) && streams.Videotext;
        public void SplitFiles()
        {
            // Prepare receiption
            var station = GetDefaultStation();

            // Prepare selection
            var selection = new StreamSelection { Videotext = true, ProgramGuide = false };

            // Add all
            selection.AC3Tracks.LanguageMode = LanguageModes.All;
            selection.MP2Tracks.LanguageMode = LanguageModes.All;
            selection.SubTitles.LanguageMode = LanguageModes.All;

            // Get a file name
            var tempFile = GetUniqueFile();

            // Get the file name pattern
            var filePattern = Path.Combine( tempFile.DirectoryName, Path.GetFileNameWithoutExtension( tempFile.Name ) );

            // Open it
            using (var streamManager = new SourceStreamsManager( Device, Profile, station.Source, selection ))
            {
                // Send to file
                streamManager.CreateStream( string.Format( FileNamePattern, filePattern, 0 ), station );

                // Process
                for (int i = 0; i++ < 3; Thread.Sleep( 10000 ))
                {
                    // Delay - first and last will have only half the size
                    Thread.Sleep( 10000 );

                    // New file
                    Assert.IsTrue( streamManager.SplitFile( string.Format( FileNamePattern, filePattern, i ) ) );
                }

                // Done
                streamManager.CloseStream();

                // Report
                foreach (var file in streamManager.AllFiles)
                    Console.WriteLine( file );
            }
        }
示例#28
0
 /// <summary>
 /// Prüft, ob eine Datenstromkonfiguration auch einen Extrakt der Programmzeitschrift umfasst.
 /// </summary>
 /// <param name="streams">Die Datenstromkonfiguration.</param>
 /// <returns>Gesetzt, wenn die Programmzeitschrift berücksichtigt werden soll.</returns>
 public static bool GetUsesProgramGuide(this StreamSelection streams) => (streams != null) && streams.ProgramGuide;
示例#29
0
 /// <summary>
 /// Legt fest, ob der Videotext mit aufgezeichnet werden soll.
 /// </summary>
 /// <param name="streams">Die Konfiguration der zu verwendenden Datenströme.</param>
 /// <param name="set">Gesetzt, wenn die Datenspur aktiviert werden soll.</param>
 public static void SetUsesVideotext(this StreamSelection streams, bool set) => streams.Videotext = set;
示例#30
0
        /// <summary>
        /// Ermittelt eine möglicherweise eingeschränkte Datenstromauswahl.
        /// </summary>
        /// <param name="manager">Die Quelle, um die es geht.</param>
        /// <returns>Eine geeignete Auswahl.</returns>
        private StreamSelection GetOptimizedStreams( SourceStreamsManager manager )
        {
            // Not possible
            if (null == CurrentSelection)
                return null;

            // What we want to record
            StreamSelection selection = new StreamSelection();

            // Put it on
            selection.AC3Tracks.LanguageMode = LanguageModes.All;
            selection.MP2Tracks.LanguageMode = LanguageModes.All;
            selection.SubTitles.LanguageMode = LanguageModes.All;
            selection.ProgramGuide = true;
            selection.Videotext = true;

            // See if we are working on a limited device
            if (!Device.HasConsumerRestriction)
                return selection;

            // Stop picture for a moment
            Device.SetConsumerState( VideoId, false );
            Device.SetConsumerState( AudioId, false );
            Device.SetConsumerState( TextId, false );

            // Require restart
            m_NeedRestart = true;

            // Create a brand new optimizer
            StreamSelectionOptimizer localOpt = new StreamSelectionOptimizer();

            // Add the one stream
            localOpt.Add( CurrentSelection, selection );

            // Run the optimization
            localOpt.Optimize();

            // Report result
            return localOpt.GetStreams( 0 );
        }
示例#31
0
        /// <summary>
        /// Wendet eine Deaktivierung auf eine Auswahl von Teildatenströmen (PID) an.
        /// </summary>
        /// <param name="streams">Die aktuelle Auswahl.</param>
        /// <param name="disable">Der gewünschte Aspekt.</param>
        /// <param name="mode">Der aktuelle Korrekturkontext der zugehörigen Quelle.</param>
        /// <param name="needed">Die Anzahl der noch benötigten Verbraucher, die geeignet korrigiert wird.</param>
        /// <param name="report">Protokolliert die vorgenommene Veränderung.</param>
        /// <returns>Gesetzt, wenn eine Veränderung stattgefunden hat.</returns>
        public static bool ApplyDisable(this StreamSelection streams, StreamDisableSelector disable, StreamDisableMode mode, ref int needed, Action <string, int> report)
        {
            // Check mode first
            switch (mode)
            {
            case StreamDisableMode.Self:
            {
                // All supported
                switch (disable)
                {
                case StreamDisableSelector.AC3IfMP2ExistsSelf: return(streams.RemoveAC3AudioIfMP2Present(ref needed, report));

                case StreamDisableSelector.AlternateAC3Self: return(streams.RemoveAlternateAC3Audio(ref needed, report));

                case StreamDisableSelector.AlternateMP2Self: return(streams.RemoveAlternateMP2Audio(ref needed, report));

                case StreamDisableSelector.MP2IfAC3ExistsSelf: return(streams.RemoveMP2AudioIfAC3Present(ref needed, report));

                case StreamDisableSelector.SubTitlesSelf: return(streams.RemoveSubTitles(ref needed, report));

                case StreamDisableSelector.VideoTextSelf: return(streams.RemoveVideoText(ref needed, report));
                }

                // Done
                break;
            }

            case StreamDisableMode.Higher:
            {
                // All supported
                switch (disable)
                {
                case StreamDisableSelector.AC3IfMP2ExistsHigher: return(streams.RemoveAC3AudioIfMP2Present(ref needed, report));

                case StreamDisableSelector.AlternateAC3Higher: return(streams.RemoveAlternateAC3Audio(ref needed, report));

                case StreamDisableSelector.AlternateMP2Higher: return(streams.RemoveAlternateMP2Audio(ref needed, report));

                case StreamDisableSelector.MP2IfAC3ExistsHigher: return(streams.RemoveMP2AudioIfAC3Present(ref needed, report));

                case StreamDisableSelector.SubTitlesHigher: return(streams.RemoveSubTitles(ref needed, report));

                case StreamDisableSelector.VideoTextHigher: return(streams.RemoveVideoText(ref needed, report));
                }

                // Done
                break;
            }

            case StreamDisableMode.Lower:
            {
                // All supported
                switch (disable)
                {
                case StreamDisableSelector.AC3IfMP2ExistsLower: return(streams.RemoveAC3AudioIfMP2Present(ref needed, report));

                case StreamDisableSelector.AlternateAC3Lower: return(streams.RemoveAlternateAC3Audio(ref needed, report));

                case StreamDisableSelector.AlternateMP2Lower: return(streams.RemoveAlternateMP2Audio(ref needed, report));

                case StreamDisableSelector.MP2IfAC3ExistsLower: return(streams.RemoveMP2AudioIfAC3Present(ref needed, report));

                case StreamDisableSelector.SubTitlesLower: return(streams.RemoveSubTitles(ref needed, report));

                case StreamDisableSelector.VideoTextLower: return(streams.RemoveVideoText(ref needed, report));
                }

                // Done
                break;
            }
            }

            // None found
            return(false);
        }