SAT>IP

[FlyGuy94 6]

So do I have to switch to beta or dev to test this?

[Guest Diefenthal]

the current state is that Network attached Sat>Ip  Servers can be discovered and that emby can send receive Sat>Ip Server Control Messages (Rtsp).

 

The other things how receive RTP (Mpeg2TS) and the reading of that and receive of RTCP(Media Control) is not inbuild .

sure the classes for RTP RTCP are commited  but not used currently.

 

the Problem my Sparetime where i write the code for  Mpeg2Ts is limited and that here no others want help there out

 

here some code snippets

 public class TsPacket
    {
        #region Fields
        private byte _syncByte;
        private bool _transportErrorIndicator;
        private bool _payloadStartIndicator;
        private bool _transportPriorityIndicator;
        private int _pid;
        private int _transportScramblingControl;
        private int _adaptionFieldControl;
        private int _adaptionLength;
        private int _continuityCount;
        private bool _scramblingControl;
        private int _lastIndex; 
        #endregion
        #region Constructor
        /// <summary>
        /// Initialize a new instance of the TransportPacket class.
        /// </summary>
        public TsPacket()
        {

        }
        #endregion
        #region Properties
        /// <summary>
        /// Get the sync byte.
        /// </summary>
        public byte SyncByte { get { return (_syncByte); } }
        /// <summary>
        /// Get the error indicator.
        /// </summary>
        public bool TransportErrorIndicator { get { return (_transportErrorIndicator); } }
        /// <summary>
        /// Get the start indicator.
        /// </summary>
        public bool PayloadUnitStartIndicator { get { return (_payloadStartIndicator); } }
        /// <summary>
        /// Get the priority indicator.
        /// </summary>
        public bool TransportPriorityIndicator { get { return (_transportPriorityIndicator); } }
        /// <summary>
        /// Gets the PID.
        /// </summary>
        public int Pid { get { return (_pid); } }
        /// <summary>
        /// Get the scambling control.
        /// </summary>
        public int TransportScramblingControl { get { return (_transportScramblingControl); } }
        /// <summary>
        /// Get the Adaption Field Control.
        /// </summary>
        public int AdaptionFieldControl { get { return (_adaptionFieldControl); } }
        /// <summary>
        /// Get the continuity count.
        /// </summary>
        public int ContinuityCount { get { return (_continuityCount); } }
        /// <summary>
        /// Returns true if it is a null packet; false otherwise.
        /// </summary>
        public bool IsNullPacket { get { return (_pid == 0x1fff); } }
        /// <summary>
        /// Returns true if the packet has a payload; false otherwise.
        /// </summary>
        public bool HasPayload { get { return (_adaptionFieldControl == 1 || _adaptionFieldControl == 3); } }
        /// <summary>
        /// Returns true if the packet is scrmabled; false otherwise.
        /// </summary>
        public bool IsScrambled { get { return (_transportScramblingControl != 0); } }
        /// <summary>
        /// Get the index of the next byte in the section following this packet.
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// The packet has not been processed.
        /// </exception>
        public virtual int Index
        {
            get
            {
                if (_lastIndex == -1)
                    throw (new InvalidOperationException("TransportPacket: Index requested before block processed"));
                return (_lastIndex);
            }
        } 
        #endregion
        #region Methods
        /// <summary>
        /// Parse the packet.
        /// </summary>
        /// <param name="byteData">The buffer section containing the packet.</param>        
        public virtual void Process(byte[] byteData)
        {
            _lastIndex = 0;

            try
            {
                _syncByte = byteData[_lastIndex];
                _lastIndex++;

                _transportErrorIndicator = (byteData[_lastIndex] & 0x80) != 0;
                _payloadStartIndicator = (byteData[_lastIndex] & 0x40) != 0;
                _transportPriorityIndicator = (byteData[_lastIndex] & 0x20) != 0;
                _pid = ((byteData[_lastIndex] & 0x1f) * 256) + byteData[_lastIndex + 1];
                _lastIndex += 2;

                _transportScramblingControl = byteData[_lastIndex] >> 6;
                _adaptionFieldControl = (byte)(byteData[_lastIndex] & 0x30) >> 4;
                _continuityCount = (byte)byteData[_lastIndex] & 0x0f;
                _lastIndex++;

                switch (_adaptionFieldControl)
                {
                    case 1:
                        _adaptionLength = 0;
                        break;
                    case 2:
                    case 3:
                        _adaptionLength = (int)byteData[_lastIndex];
                        _lastIndex += _adaptionLength;
                        break;
                    default:
                        break;
                }
                _lastIndex++;
                Validate();
            }
            catch (IndexOutOfRangeException)
            {
                throw (new ArgumentOutOfRangeException("Block length: " + byteData.Length + " last index: " + _lastIndex));
            }
        }

        /// <summary>
        /// Validate the packet fields.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">
        /// A packet field is not valid.
        /// </exception>
        public void Validate()
        {
            if (_syncByte != 0x47)
                throw (new ArgumentOutOfRangeException("Sync byte"));
        } 
        #endregion
        #region Overrides
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Transportstream Packet .\n");
            sb.AppendFormat("Sync Byte: {0} .\n", SyncByte.ToString());
            sb.AppendFormat("Transport Error Indicator: {0} .\n", TransportErrorIndicator);
            sb.AppendFormat("Payload Unit Start Indicator: {0} .\n", PayloadUnitStartIndicator);
            sb.AppendFormat("Transport Priority: {0} .\n", TransportPriorityIndicator);
            sb.AppendFormat("PID: {0} .\n", Pid);
            sb.AppendFormat("Transport Scrambling Control: {0} .\n", TransportScramblingControl);
            sb.AppendFormat("Adaption Field Control: {0} .\n", AdaptionFieldControl);
            sb.AppendFormat("Continuity Counter: {0} .\n", ContinuityCount);
            sb.AppendFormat(".\n");
            return sb.ToString();
        } 
        #endregion
   }

public class TsTable :TsPacket
    {
        #region Fields
        private int _tableID;
        private int _sectionLength;
        private bool _privateIndicator;
        private bool _syntaxIndicator;
        private int _tableIDExtension;
        private bool _currentNextIndicator;
        private int _versionNumber;
        private int _sectionNumber;
        private int _lastSectionNumber;
        private int _lastIndex = -1;
        private int _dataLength;
        #endregion
        #region Constructor
        public TsTable() { }
        #endregion
        #region Properties
        /// <summary>
        /// Get the table identification.
        /// </summary>
        public int TableID { get { return (_tableID); } }
        /// <summary>
        /// Get the section length.
        /// </summary>
        public int SectionLength { get { return (_sectionLength); } }
        /// <summary>
        /// Return true if the section is private data; false otherwise.
        /// </summary>
        public bool PrivateIndicator { get { return (_privateIndicator); } }
        /// <summary>
        /// Return true if the sysntax indicator is set; false otherwise.
        /// </summary>
        public bool SyntaxIndicator { get { return (_syntaxIndicator); } }
        /// <summary>
        /// Get the table identification extension.
        /// </summary>
        public int TableIDExtension { get { return (_tableIDExtension); } }
        /// <summary>
        /// Return true if the MPEG2 section is current; false otherwise.
        /// </summary>
        public bool CurrentNextIndicator { get { return (_currentNextIndicator); } }
        /// <summary>
        /// Get the version number.
        /// </summary>
        public int VersionNumber { get { return (_versionNumber); } }
        /// <summary>
        /// Get the section number.
        /// </summary>
        public int SectionNumber { get { return (_sectionNumber); } }
        /// <summary>
        /// Get the last section number.
        /// </summary>
        public int LastSectionNumber { get { return (_lastSectionNumber); } }
        /// <summary>
        /// Return true if the MPEG2 section is current; false otherwise.
        /// </summary>
        public bool Current { get { return (_currentNextIndicator); } }
        
        #endregion
        #region Methods
        /// <summary>
        /// Parse the header.
        /// </summary>
        /// <param name="byteData">The MPEG2 section containing the header.</param>
        public override void Process(byte[] byteData)
        {
            base.Process(byteData);
            _lastIndex = base.Index;
            _dataLength = byteData.Length;
            if (!IsNullPacket)
            {

                try
                {
                    _tableID = (int)byteData[_lastIndex];
                    _lastIndex++;
                    _syntaxIndicator = (byteData[_lastIndex] & 0x80) != 0;
                    _privateIndicator = (byteData[_lastIndex] & 0x40) != 0;
                    _sectionLength = ((byteData[_lastIndex] & 0x0f) * 256) + (int)byteData[_lastIndex + 1];
                    _lastIndex += 2;
                    _tableIDExtension = (byteData[_lastIndex] * 256) + (int)byteData[_lastIndex + 1];
                    _lastIndex += 2;
                    _versionNumber = ((int)((byteData[_lastIndex] >> 1) & 0x1f));
                    _currentNextIndicator = (byteData[_lastIndex] & 0x01) != 0;
                    _lastIndex++;
                    _sectionNumber = (int)byteData[_lastIndex];
                    _lastIndex++;
                    _lastSectionNumber = (int)byteData[_lastIndex];
                    _lastIndex++;
                    Validate();
                }
                catch (IndexOutOfRangeException)
                {
                    throw (new ArgumentOutOfRangeException("MPEG2 basic header is short"));
                }
            }
        }

        /// <summary>
        /// Validate the header fields.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">
        /// A header field is not valid.
        /// </exception>
        public virtual void Validate()
        {
            if (_dataLength > 4096)
                throw (new ArgumentOutOfRangeException("MPEG2 Section data length wrong"));

            if (_sectionLength < 1 || _sectionLength > _dataLength - 3)
                throw (new ArgumentOutOfRangeException("MPEG2 Section length wrong"));
        }

	    #endregion
        #region Overrides
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat( base.ToString());
            sb.AppendFormat("Transportstream Table .\n");
            sb.AppendFormat("TableID: {0} .\n", TableID);
            sb.AppendFormat("SectionLength: {0} .\n", SectionLength);
            sb.AppendFormat("PrivateIndicator: {0} .\n", PrivateIndicator);
            sb.AppendFormat("SyntaxIndicator: {0} .\n", SyntaxIndicator);
            sb.AppendFormat("TableIDExtension: {0} .\n", TableIDExtension);
            sb.AppendFormat("CurrentNextIndicator: {0} .\n", CurrentNextIndicator);
            sb.AppendFormat("VersionNumber: {0} .\n", VersionNumber);
            sb.AppendFormat("SectionNumber: {0} .\n", SectionNumber);
            sb.AppendFormat("LastSectionNumber: {0} .\n", LastSectionNumber);            
            sb.AppendFormat(".\n");
            return sb.ToString();
        } 
        #endregion
    }

public class ServiceDescriptionTable : TsTable
    {
        #region Fields
        private int _lastIndex = -1;
        private int _originalNetworkID = -1;
        private int _reserved1;
        private int _sectionNumber;
        private Collection<ServiceDescription> serviceDescriptions = new Collection<ServiceDescription>();
        private int _transportStreamID = -1;
        #endregion
        #region Constructor
        /// <summary>
        /// 
        /// </summary>
        public ServiceDescriptionTable() { } 
        #endregion
        #region Methods
        public override void Process(byte[] byteData)
        {
            base.Process(byteData);
            _lastIndex = base.Index;
            if (Current)
            {
                _transportStreamID = TableIDExtension;
                _sectionNumber = SectionNumber;
                _originalNetworkID = Utils.Convert2BytesToInt(byteData, _lastIndex);
                _lastIndex += 2;
                _reserved1 = byteData[_lastIndex];
                _lastIndex++;
                while (_lastIndex < (byteData.Length - 4))
                {
                    ServiceDescription item = new ServiceDescription();
                    item.Process(byteData, _lastIndex);
                    serviceDescriptions.Add(item);
                    _lastIndex = item.Index;
                }
            }
        } 
        #endregion

        public override string ToString()
        {
            return base.ToString();
        }
    }

 

public class ServiceDescription
    {
        private int _lastIndex = -1;
        private int _serviceID;
        private bool _eitScheduleFlag;
        private bool _eitPresentFollowingFlag;
        private RunningStatus _runningStatus;
        private bool _scrambled;
        private int _descriptorsLoopLength;
        private Collection<Descriptor> _descriptors;

        
        public int Index
        {
            get
            {
                if (_lastIndex == -1)
                {
                    throw new InvalidOperationException("ServiceDescription: Index requested before block processed");
                }
                return _lastIndex;
            }
        }
        internal void Process(byte[] byteData, int index)
        {
            _descriptors = new Collection<Descriptor>();
            _lastIndex = index;
            _serviceID = Utils.Convert2BytesToInt(byteData, _lastIndex);
            _lastIndex += 2;
            _eitScheduleFlag = (byteData[_lastIndex] & 2) != 0;
            _eitPresentFollowingFlag = (byteData[_lastIndex] & 1) != 0;
            _lastIndex++;
            _runningStatus = (RunningStatus)(byteData[_lastIndex] >> 5);
            _scrambled = ((byteData[_lastIndex] & 0x10) >> 4) == 1;
            _descriptorsLoopLength = (((byteData[_lastIndex] & 15) * 0x100) + byteData[_lastIndex + 1]);
            _lastIndex += 4;
            while (_descriptorsLoopLength != 0)
            {
                Descriptor descriptor = Descriptor.GetDescriptor(byteData, _lastIndex);
                if (descriptor.DescriptorLength > 0)
                {
                    _descriptors.Add(descriptor);
                    _lastIndex = descriptor.Index;
                    _descriptorsLoopLength -= descriptor.TotalDescriptorLength;
                }
                else
                {
                    _lastIndex += Descriptor.MinimumDescriptorLength;
                    _descriptorsLoopLength -= Descriptor.MinimumDescriptorLength;
                }               
            }
        }
    }
    public class ServiceDescriptor : Descriptor
    {
        #region Fields
        private int _serviceType = -1;
        private string _providerName;
        private string _serviceName;
        private int _lastIndex = -1; 
        #endregion
        #region Constructor
        /// <summary>
        /// Initialize a new instance of the ServiceDescriptor class. 
        /// </summary>
        public ServiceDescriptor() { } 
        #endregion
        #region Properties
        /// <summary>
        /// Get the service type.
        /// </summary>
        public int ServiceType { get { return (_serviceType); } }

        /// <summary>
        /// Get the provider name.
        /// </summary>
        public string ProviderName { get { return (_providerName); } }

        /// <summary>
        /// Get the service name.
        /// </summary>
        public string ServiceName { get { return (_serviceName); } }

        /// <summary>
        /// Get the index of the next byte in the EIT section following this descriptor.
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// The descriptor has not been processed.
        /// </exception> 
        public override int Index
        {
            get
            {
                if (_lastIndex == -1)
                    throw (new InvalidOperationException("ServiceDescriptor: Index requested before block processed"));
                return (_lastIndex);
            }
        } 
        #endregion
        /// <summary>
        /// Parse the descriptor.
        /// </summary>
        /// <param name="byteData">The MPEG2 section containing the descriptor.</param>
        /// <param name="index">Index of the byte in the MPEG2 section following the descriptor length.</param>
        internal override void Process(byte[] byteData, int index)
        {
            _lastIndex = index;

            try
            {
                _serviceType = (int)byteData[_lastIndex];
                _lastIndex++;

                int providerNameLength = (int)byteData[_lastIndex];
                _lastIndex++;

                if (providerNameLength != 0)
                {
                    //_providerName = Utils.GetString(byteData, _lastIndex, providerNameLength);
                    _lastIndex += providerNameLength;
                }
                int serviceNameLength = (int)byteData[_lastIndex];
                _lastIndex++;
                if (serviceNameLength != 0)
                {
                    //_serviceName = Utils.GetString(byteData, _lastIndex, serviceNameLength);
                    _lastIndex += serviceNameLength;
                }                
            }
            catch (IndexOutOfRangeException)
            {
                throw (new ArgumentOutOfRangeException("The Service Descriptor message is short"));
            }
        }

    }

public class Descriptor
    {
        private int _lastIndex = -1;
        private int _descriptorTag;
        private int _descriptorLength;
        private byte[] _data;
        /// <summary>
        /// Get the index of the next byte in the MPEG2 section following this descriptor.
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// The descriptor has not been processed.
        /// </exception> 
        public virtual int Index
        {
            get
            {
                if (_lastIndex == -1)
                    throw (new InvalidOperationException("Descriptor: Index requested before block processed"));
                return (_lastIndex);
            }
        }
        /// <summary>
        /// Get the tag of the record.
        /// </summary>
        internal int DescriptorTag { get { return (_descriptorTag); } }
        /// <summary>
        /// Get the length of the descriptor data.
        /// </summary>
        internal int DescriptorLength { get { return (_descriptorLength); } }
        /// <summary>
        /// Get the total length of the descriptor.
        /// </summary>
        internal int TotalDescriptorLength { get { return (DescriptorLength + 2); } }
        /// <summary>
        /// Return the minimum descriptor length in bytes.
        /// </summary>
        internal static int MinimumDescriptorLength { get { return (2); } }

        public static Descriptor GetDescriptor(byte[] byteData, int index)
        {
            Descriptor descriptor;
            switch ((int)byteData[index])
            {
                case 0x48:
                    descriptor = new ServiceDescriptor();
                    break;
                default:
                    descriptor = new Descriptor();
                    break;
            }
            descriptor._descriptorTag = (int)byteData[index];
            index++;

            descriptor._descriptorLength = (int)byteData[index];
            index++;

            if (descriptor.DescriptorLength != 0)
                descriptor.Process(byteData, index);

            return (descriptor);
        }
        /// <summary>
        /// Parse the descriptor.
        /// </summary>
        /// <param name="byteData">The MPEG2 section containing the descriptor.</param>
        /// <param name="index">Index of the byte in the MPEG2 section following the descriptor length.</param>
        internal virtual void Process(byte[] byteData, int index)
        {
            _lastIndex = index ;

            if (DescriptorLength != 0)
            {
                _data = Utils.GetBytes(byteData, index, DescriptorLength);
                _lastIndex += DescriptorLength;
            }            
        }
    }

long story short

 

it hangs on Table / Descriptor Decoding

Edited September 20, 2016 by Diefenthal

[Guest Diefenthal]

An Little update

 

addet rtp receiving to the Scan Sample

added some first code for MPEG2TS parsing

(Program AssociationTable should be stable ,ServiceDescriptionTable and ProgramMapTable not! the is the descriptor coding needed)

 

with other words what you see in the ListView object are the results from the PAT

 

 

[Nikolaech 32]

Hello Diefenthal   the zip archive is empty

[Guest Diefenthal]

Hello Diefenthal   the zip archive is empty

ooooopps

[Nikolaech 32]

Not working. What's wrong?

 

[Guest Diefenthal]

Sat>Ip Spec 1.2.2 Page 51 of 70

Status code
404 – Not Found
Description
The server has not found anything matching the Request-URI.
Returned when requesting a stream with a streamID that does not exist.

more can i not say without to see the rtsp communication between Client (scan sample) and Server (dvbviewer rs )
what dvbvrs send or not

in the next update should you get an more informative message box ;-)

private string GetMessageFromStatuscode(RtspStatusCode code)
        {
            var retval = string.Empty;
            switch (code)
            {
                case RtspStatusCode.BadRequest:
                    retval = "The request could not be understood by the server due to a malformed syntax. Returned when missing a character, inconsistent request (duplicate attributes), etc.";
                    break;
                case RtspStatusCode.Forbidden:
                    retval = "The server understood the request, but is refusing to fulfil it. Returned when passing an attribute value not understood by the server in a query, or an out-of-range value.";
                    break;
                case RtspStatusCode.NotFound:
                    retval = "The server has not found anything matching the Request-URI. Returned when requesting a stream with a streamID that does not exist.";
                    break;
                case RtspStatusCode.MethodNotAllowed:
                    retval = "The method specified in the request is not allowed for the resource identified by the Request-URI. Returned when applying a SETUP, PLAY or TEARDOWN method on an RTSP URI identifying the server.";
                    break;
                case RtspStatusCode.NotAcceptable:
                    retval = "The resource identified by the request is only capable of generating response message bodies which have content characteristics not acceptable according to the accept headers sent in the request. Issuing a DESCRIBE request with an accept header different from application/sdp.";
                    break;
                case RtspStatusCode.RequestTimeOut:
                    retval = "The client did not produce a request within the time that the server was prepared to wait. The client may repeat the request without modifications at any later time. E.g. issuing a PLAY request after the communication link had been idle for a period of time. The time interval has exceeded the value specified by the timeout parameter in the Session: header field of a SETUP response.";
                    break;
                case RtspStatusCode.RequestUriTooLarge:
                    retval = "The server is refusing to service the request because the Request-URI is longer than the server is willing to interpret. The RTSP protocol does not place any limit on the length of a URI. Servers should be able to handle URIs of unbounded length.";
                    break;
                case RtspStatusCode.NotEnoughBandwidth:
                    retval = "The request was refused because there is insufficient bandwidth on the in-home LAN. Returned when clients are requesting more streams than the network can carry.";
                    break;
                case RtspStatusCode.SessionNotFound:
                    retval = "The RTSP session identifier value in the Session: header field of the request is missing, invalid, or has timed out. Returned when issuing the wrong session identifier value in a request.";
                    break;
                case RtspStatusCode.MethodNotValidInThisState:
                    retval = "The client or server cannot process this request in its current state. Returned e.g. when trying to change transport parameters while the server is in the play state (e.g. change of port values, etc.).";
                    break;
                case RtspStatusCode.UnsupportedTransport:
                    retval = "The Transport: header field of the request did not contain a supported transport specification. Returned e.g. when issuing a profile that is different from RTP/AVP.";
                    break;
                case RtspStatusCode.InternalServerError:
                    retval = "The server encountered an error condition preventing it to fulfil the request. Returned when the server is not functioning correctly due to a hardware failure or a software bug or anything else that can go wrong.";
                    break;
                case RtspStatusCode.ServiceUnavailable:
                    retval = "The server is currently unable to handle the request due to a temporary overloading or maintenance of the server. Returned when reaching the maximum number of hardware and software resources, the maximum number of sessions.";
                    break;
                case RtspStatusCode.RtspVersionNotSupported:
                    retval = "The server does not support the RTSP protocol version that was used in the request message.";
                    break;
                case RtspStatusCode.OptionNotSupported:
                    retval = "A feature-tag given in the Require: header field of the request was not supported. Issuing a request with a Require: header field.";
                    break;
            }
            return retval;
        }

if you want fix it locally

var message = GetMessageFromStatuscode(statuscode);
                            MessageBox.Show(String.Format("Setup retuns {0}", message), statuscode.ToString(), MessageBoxButtons.OK);

 

Edited September 29, 2016 by Diefenthal

[Nikolaech 32]

may I help you?

[Guest Diefenthal]

@@Nikolaech

 

how would you me help

 

for dvbviewer rs Support ?

 

ok the only way to help me there is an wireshark capture

that logs all  rtsp rtp

 

an other way isnt possible i had no BDA Tv Cards more  had it all sold

 

or will you help me with code writing  and bug hunting ?

Edited September 30, 2016 by Diefenthal

[Nikolaech 32]

for dvbviewer rs Support ?

 

no. plugin from @@pünktchen works well.

 

 

or will you help me with code writing  and bug hunting ?

 

no I'm not a programmer

 

 

ok the only way to help me there is an wireshark capture that logs all  rtsp rtp

 

what "wireshark"? https://de.wikipedia.org/wiki/Wireshark  ?

[Guest Diefenthal]

no. plugin from @@pünktchen works well.

 

 

 

no I'm not a programmer

 

 

 

what "wireshark"? https://de.wikipedia.org/wiki/Wireshark  ?

https://www.wireshark.org/

[Guest Diefenthal]

hmm you said

 

 

no. plugin from @pünktchen works well.

 

some others say tvheadend works well too

 

What conclusions should I draw from it??

my proof of concept is not needed?

[Luke 37049]

hmm you said

 

 

some others say tvheadend works well too

 

What conclusions should I draw from it??

my proof of concept is not needed?

 

Well it would be nice to not require plugins, so that's why we continue with Sat/Ip.

[Guest Diefenthal]

@@Luke no Panic

 

if i had time will i work on the p.o.c.

 

firstly to teach me self  how it work and what not

and share the results  if they needed

 

but here i wish me really more help

 

an other had it good describe what for an work it  is

[Nikolaech 32]

 

my proof of concept is not needed?

 

Necessary!!!

[Nikolaech 32]

https://www.wireshark.org/

 

Installed the program. What to do next?

[Guest Diefenthal]

start wireshark in legacy mode

should Looks like so

 

 

 

type rtsp into the filter field

 

 

 

click on apply,  after that on the shark fin  

 

 

 

wireshark is now listening for any rtsp request and Responses

 

now start the scan sample  choose there the DVBViewer  RS instance 

and let start the search  in wireshark should be now Messages logged

 

 

 

search the first discribe Response  click on it

 

and on the bottomside see you all things that the Server had send back to the Client

expand  Session Description Protocol node

 

 

 

the marked line is what i will know

 

or save the complet capture and send it to KayDiefenthal at Hotmail dot de

Edited October 7, 2016 by Diefenthal

[Nikolaech 32]

Thank you. While it is impossible, the interface is slightly different. I'll try to understand.

 

does not work. something I did not do so.

 

maybe because on the same machine?

 

Edited October 7, 2016 by Nikolaech

[Guest Diefenthal]

multible Network Cards Interfaces ?

[Nikolaech 32]

no.
one card SS2 Express HD

[Guest Diefenthal]

Looks like that the describe request make Trouble

sure i can it disable but than had i no control for SignalLocked

the Parser should first start if the Signal is locked

 

some others Clients (EpgCollector) had the same Problem with it

http://www.dvbviewer.tv/forum/topic/58638-recording-service-streaming-problems/

[Nikolaech 32]

I think that's okay. No reason to make a universal application. The app should work with Sat-Ip device Octopus Triax

[Guest Diefenthal]

 

yes in the first step should ignore i the dvbviewer rs and hope thal all other Hardware base SatIp Servers working

 

with an Little luck Change the DvbViewer Team her DvbViewer RS so that it is Sat>ip spec conform

[Guest Diefenthal]

ok had buy an cheap dvbt usb stick install dvbviewer + recording Service

 

the Recording Server is found in my samples but the rtsp communication over port 554 doesnt work the recording Server use any free port in my tests 555

and the 555 port value can only found in recording Servers m3u

 

so i think it is so not possible for all other Sat>Ip Client to use Recording Server as Source

[Nikolaech 32]

ok had buy an cheap dvbt usb stick install dvbviewer + recording Service

 

 

Order?

https://de.aliexpress.com/item/Digital-Antenna-USB-2-0-HDTV-TV-Remote-Tuner-Recorder-Receiver-for-DVB-T2-DVB-T/1762546890.html?spm=2114.12010208.1000013.6.Ocf42P&scm=1007.13339.33317.0&pvid=c4647261-53fc-4858-9c6a-a0272132564c&tpp=1&detailNewVersion=&categoryId=200005122

 

 

http://blog.palosaari.fi/2013/10/naked-hardware-14-dvb-t2-usb-tv-stick.html

 

In Kazakhstan broadcasting DVB-T2.

Edited October 19, 2016 by Nikolaech