/// <summary>
/// <see cref="RtspDataChunk.Clone"/>
/// </summary>
/// <returns></returns>
public object Clone()
{
InterleavedData data = new InterleavedData(Channel);
Data.CopyTo(data.Data, 0);
return(data);
}
private void Reset(ReadingState state = ReadingState.SkipControlChars)
{
_message = null;
_interleavedPacket = null;
_chunkSize = 0;
_bufferIdx = 0;
_state = state;
}
public RtspMessageDecoder(IPEndPoint remoteEndpoint)
{
_message = null;
_chunkSize = 0;
_bufferIdx = 0;
_interleavedPacket = null;
_remoteEndpoint = remoteEndpoint;
_lineReader = new LineReader();
_state = ReadingState.SkipControlChars;
}
public bool Decode(MemoryStream stream, out RtspChunk chunk)
{
chunk = null;
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
switch (_state)
{
case ReadingState.SkipControlChars:
{
SkipControlCharacters(reader);
_state = ReadingState.ReadInitial;
break;
}
case ReadingState.ReadInitial:
{
char currentChar = Convert.ToChar(reader.PeekChar());
if (currentChar == INTERLEAVED_MARKER)
{
_state = ReadingState.ReadInterleavedData;
return(false);
}
else
{
try
{
string line = _lineReader.Read(reader);
string[] parts = SplitInitialLine(line);
if (parts.Length < 3)
{
// This is an invalid initial line just ignore it.
LOG.Warn($"Invalid start of RTSP message: '{line}', ignoring...");
_state = ReadingState.SkipControlChars;
return(false);
}
else
{
_message = RtspMessage.CreateNewMessage(parts, _remoteEndpoint);
_state = ReadingState.ReadHeader;
}
}
catch (Exception e)
{
LOG.Error($"Failed to parse RTSP message, reason: {e.Message}");
_state = ReadingState.BadMessage;
}
}
break;
}
case ReadingState.ReadHeader:
{
_state = ReadHeaders(_message, reader);
// If the check size is greater than zero it will be decreased as the
// ReadFixedContentLength state reads the body chunk by chunk.
_chunkSize = _message.ContentLength;
if (_state == ReadingState.SkipControlChars || (_chunkSize <= 0))
{
// No content data expected.
// TODO(frank.lamar): Add support for chunking. Not important
// at the moment because I have yet to see a device use chunking.
chunk = _message;
Reset();
return(true);
}
break;
}
case ReadingState.ReadFixedContentLength:
{
if (_bufferIdx == 0)
{
// We are reading the first chunk of data. We need to first
// allocate the message's data array.
_message.Body = new byte[_chunkSize];
}
int bytesRead = reader.Read(_message.Body, _bufferIdx, _chunkSize);
_chunkSize -= bytesRead; // Decrement the bytes read from the chunk size.
_bufferIdx += bytesRead; // Increment the index to write next chunk to.
if (_chunkSize == 0)
{
chunk = _message;
Reset();
return(true);
}
break;
}
case ReadingState.ReadInterleavedData:
{
if (_chunkSize == 0 && _bufferIdx == 0)
{
reader.ReadByte(); // Consume the '$' marker left in the buffer.
byte channel = reader.ReadByte();
_chunkSize = GetUint16(reader);
_interleavedPacket = new InterleavedData(channel);
_interleavedPacket.Payload = new byte[_chunkSize];
}
int bytesRead = reader.Read(_interleavedPacket.Payload, _bufferIdx, _chunkSize);
_chunkSize -= bytesRead; // Decrement the bytes read from the chunk size.
_bufferIdx += bytesRead; // Increment the index to write next chunk to.
if (_chunkSize == 0)
{
chunk = _interleavedPacket;
Reset();
return(true);
}
break;
}
case ReadingState.BadMessage:
{
LOG.Debug("Unable to decode RTSP message, ignoring messsage");
stream.Seek(0, SeekOrigin.End); // Skip the remaining buffer.
Reset();
break;
}
default:
{
LOG.Warn($"Unknown state: {_state}");
Reset();
break;
}
}
}
return(false);
}