public void PushMessage(IPipe pipe, IMessage message)
{
if (message is ResetMessage)
{
_timeStamper.Reset();
}
else if (message is StatusMessage)
{
StatusMessage statusMsg = message as StatusMessage;
_data.SendStatus(statusMsg.body as StatusASO);
}
else if (message is RtmpMessage)
{
// Make sure chunk size has been sent
if (!_chunkSizeSent)
SendChunkSize();
RtmpMessage rtmpMsg = message as RtmpMessage;
IRtmpEvent msg = rtmpMsg.body;
int eventTime = msg.Timestamp;
#if !SILVERLIGHT
if(log.IsDebugEnabled)
log.Debug(string.Format("Message timestamp: {0}", eventTime));
#endif
if (eventTime < 0)
{
#if !SILVERLIGHT
if (log.IsDebugEnabled)
log.Debug(string.Format("Message has negative timestamp: {0}", eventTime));
#endif
return;
}
byte dataType = msg.DataType;
// Create a new header for the consumer
RtmpHeader header = _timeStamper.GetTimeStamp(dataType, eventTime);
switch (msg.DataType)
{
case Constants.TypeStreamMetadata:
Notify notify = new Notify((msg as Notify).Data);
notify.Header = header;
notify.Timestamp = header.Timer;
_data.Write(notify);
break;
case Constants.TypeFlexStreamEnd:
// TODO: okay to send this also to AMF0 clients?
FlexStreamSend send = new FlexStreamSend((msg as Notify).Data);
send.Header = header;
send.Timestamp = header.Timer;
_data.Write(send);
break;
case Constants.TypeVideoData:
VideoData videoData = new VideoData((msg as VideoData).Data);
videoData.Header = header;
videoData.Timestamp = header.Timer;
_video.Write(videoData);
break;
case Constants.TypeAudioData:
AudioData audioData = new AudioData((msg as AudioData).Data);
audioData.Header = header;
audioData.Timestamp = header.Timer;
_audio.Write(audioData);
break;
case Constants.TypePing:
Ping ping = new Ping((msg as Ping).PingType, (msg as Ping).Value2, (msg as Ping).Value3, (msg as Ping).Value4);
ping.Header = header;
_connection.Ping(ping);
break;
case Constants.TypeBytesRead:
BytesRead bytesRead = new BytesRead((msg as BytesRead).Bytes);
bytesRead.Header = header;
bytesRead.Timestamp = header.Timer;
_connection.GetChannel((byte)2).Write(bytesRead);
break;
default:
_data.Write(msg);
break;
}
}
}
/// <summary>
/// This method supports the Fluorine infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="connection"></param>
/// <param name="channel"></param>
/// <param name="source"></param>
/// <param name="streamBytesRead"></param>
protected void OnStreamBytesRead(RtmpConnection connection, RtmpChannel channel, RtmpHeader source, BytesRead streamBytesRead)
{
connection.ReceivedBytesRead(streamBytesRead.Bytes);
}
static ByteBuffer EncodeBytesRead(RtmpContext context, BytesRead bytesRead)
{
ByteBuffer output = ByteBuffer.Allocate(4);
output.PutInt(bytesRead.Bytes);
return output;
}
/// <summary>
/// Update number of bytes to read next value.
/// </summary>
protected void UpdateBytesRead()
{
BytesRead sbr = null;
try
{
ReaderWriterLock.AcquireWriterLock();
long bytesRead = this.ReadBytes;
if (bytesRead >= _nextBytesRead)
{
sbr = new BytesRead((int)bytesRead);
//GetChannel((byte)2).Write(sbr);
_nextBytesRead += _bytesReadInterval;
}
}
finally
{
ReaderWriterLock.ReleaseWriterLock();
}
if( sbr != null )
GetChannel((byte)2).Write(sbr);
}
