public void NoBufferEventAfterSubscription()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var eventCount = 0;
bufferController.BufferingStateChanged()
.Subscribe(a => eventCount++
, SynchronizationContext.Current);
if (eventCount == 0)
{
await Task.Delay(TimeSpan.FromSeconds(1));
}
Assert.IsTrue(eventCount == 0, $"Expected: eventCount == 0 Result: eventCount == {eventCount}");
}
});
}
public void DataEventAfterSingleConfigurationChange()
{
Assert.DoesNotThrow(
() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var dataArgsHolder = new DataRequest[(int)StreamType.Count];
using (bufferController.DataNeededStateChanged()
.Subscribe(a => { dataArgsHolder[(int)a.StreamType] = a; },
SynchronizationContext.Current))
{
var conf = new MetaDataStreamConfig
{
Bandwidth = 123456789,
BufferDuration = TimeSpan.FromSeconds(15),
Stream = StreamType.Audio
};
bufferController.SetMetaDataConfiguration(conf);
SpinWait.SpinUntil(() => dataArgsHolder[(int)StreamType.Audio] != null,
TimeSpan.FromSeconds(2));
Assert.IsTrue(
dataArgsHolder[(int)StreamType.Audio].CompareMetaData(conf), $"Expected: Same Result: {conf} {dataArgsHolder[(int)StreamType.Audio]}");
}
}
});
}
public void BufferFullBufferActualReported()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var dataArgsHolder = new DataRequest[(int)StreamType.Count];
var eventCount = 0;
using (bufferController.DataNeededStateChanged()
.Subscribe(a =>
{
eventCount++;
dataArgsHolder[(int)a.StreamType] = a;
}, SynchronizationContext.Current))
{
var audio = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(7), 100);
var video = BuildPacketList(StreamType.Video, TimeSpan.FromSeconds(7), 100);
await Task.WhenAll(
bufferController.PushPackets(audio),
bufferController.PushPackets(video));
SpinWait.SpinUntil(() => eventCount >= 2, TimeSpan.FromSeconds(2));
var audioLevel = dataArgsHolder[(int)StreamType.Audio].Duration;
var videoLevel = dataArgsHolder[(int)StreamType.Video].Duration;
bufferController.ReportFullBuffer();
bufferController.PublishBufferState();
SpinWait.SpinUntil(() => eventCount >= 4, TimeSpan.FromSeconds(2));
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio].Duration == TimeSpan.Zero, $"Expected: audio Duration == 0 Result: Duration=={dataArgsHolder[(int)StreamType.Audio].Duration}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video].Duration == TimeSpan.Zero, $"Expected: video Duration == 0 Result: Duration=={dataArgsHolder[(int)StreamType.Video].Duration}");
bufferController.ReportActualBuffer();
bufferController.PublishBufferState();
SpinWait.SpinUntil(() => eventCount >= 6, TimeSpan.FromSeconds(2));
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio].Duration == audioLevel);
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video].Duration == videoLevel);
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio].Duration == audioLevel, $"Expected: audio Duration == {audioLevel} Result: Duration=={dataArgsHolder[(int)StreamType.Audio].Duration}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video].Duration == videoLevel, $"Expected: video Duration == {videoLevel} Result: Duration=={dataArgsHolder[(int)StreamType.Video].Duration}");
await Task.WhenAll(
audio.DisposePackets(),
video.DisposePackets()
);
}
}
});
}
public void NoEventsWhenEventsDisabled()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var dataArgsHolder = new DataRequest[(int)StreamType.Count];
var eventCount = 0;
using (bufferController.DataNeededStateChanged()
.Subscribe(a =>
{
eventCount++;
dataArgsHolder[(int)a.StreamType] = a;
}, SynchronizationContext.Current))
{
var audio = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(15), 100);
var video = BuildPacketList(StreamType.Video, TimeSpan.FromSeconds(15), 100);
await Task.WhenAll(
bufferController.PushPackets(audio),
bufferController.PushPackets(video));
SpinWait.SpinUntil(() => eventCount >= 2, TimeSpan.FromSeconds(2));
await Task.WhenAll(
bufferController.PullPackets(audio),
bufferController.PullPackets(video));
SpinWait.SpinUntil(() => eventCount >= 4, TimeSpan.FromSeconds(2));
bufferController.EnableEvents(StreamBufferEvents.StreamBufferEvent.None);
var currEventCount = eventCount;
await Task.WhenAll(
bufferController.PushPackets(audio),
bufferController.PushPackets(video));
await Task.Delay(1500);
await Task.WhenAll(
bufferController.PullPackets(audio),
bufferController.PullPackets(video));
await Task.Delay(1500);
Assert.IsTrue(eventCount == currEventCount, $"Expected: eventCount==currEventCount Result {eventCount}!={currEventCount}");
await Task.WhenAll(
audio.DisposePackets(),
video.DisposePackets()
);
}
}
});
}
public void DataEventsAfterSubscription()
{
Assert.DoesNotThrow(
() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var dataArgsHolder = new DataRequest[(int)StreamType.Count];
var eventCount = 0;
using (bufferController.DataNeededStateChanged().Subscribe(
a =>
{
dataArgsHolder[(int)a.StreamType] = a;
eventCount++;
}, SynchronizationContext.Current))
{
SpinWait.SpinUntil(() => eventCount == 2, TimeSpan.FromSeconds(2));
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio] != null, "dataArgsHolder[(int)StreamType.Audio] != null");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video] != null, "dataArgsHolder[(int)StreamType.Video] != null");
}
}
});
}
public static async Task PullPackets(this StreamBufferController streamBuffer, IEnumerable <Packet> source)
{
foreach (var packet in source)
{
streamBuffer.DataOut(packet);
await Task.Yield();
}
}
public void DataOffOnEventFromMultipleSources()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var dataArgsHolder = new DataRequest[(int)StreamType.Count];
var eventCount = 0;
using (bufferController.DataNeededStateChanged()
.Subscribe(a =>
{
eventCount++;
dataArgsHolder[(int)a.StreamType] = a;
}, SynchronizationContext.Current))
{
var audio = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(15), 100);
var video = BuildPacketList(StreamType.Video, TimeSpan.FromSeconds(15), 100);
await Task.WhenAll(
bufferController.PushPackets(audio),
bufferController.PushPackets(video));
SpinWait.SpinUntil(() => eventCount >= 2, TimeSpan.FromSeconds(2));
Assert.IsTrue(eventCount >= 2, $"Expected: eventCount >=2 Result: eventCount={eventCount}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio].Duration <= TimeSpan.Zero, $"Expected: audio Duration <= 0 Result: Duration=={dataArgsHolder[(int)StreamType.Audio].Duration}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video].Duration <= TimeSpan.Zero, $"Expected: video Duration <= 0 Result: Duration=={dataArgsHolder[(int)StreamType.Video].Duration}");
await Task.WhenAll(
bufferController.PullPackets(audio),
bufferController.PullPackets(video));
SpinWait.SpinUntil(() => eventCount >= 4, TimeSpan.FromSeconds(2));
Assert.IsTrue(eventCount >= 4, $"Expected: eventCount >=4 Result: eventCount={eventCount}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Audio].Duration > TimeSpan.Zero, $"Expected: audio Duration > 0 Result: Duration=={dataArgsHolder[(int)StreamType.Audio].Duration}");
Assert.IsTrue(dataArgsHolder[(int)StreamType.Video].Duration > TimeSpan.Zero, $"Expected: video Duration > 0 Result: Duration=={dataArgsHolder[(int)StreamType.Video].Duration}");
await Task.WhenAll(
audio.DisposePackets(),
video.DisposePackets()
);
}
}
});
}
public void BufferOnOffEventFromSingleSource()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
var eventCount = 0;
var eventOnCount = 0;
var eventOffCount = 0;
using (bufferController.BufferingStateChanged()
.Subscribe(a =>
{
eventCount++;
if (a)
{
eventOnCount++;
}
else
{
eventOffCount++;
}
}, SynchronizationContext.Current))
{
var audioPackets1 = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(15), 100);
var audioPackets2 = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(15), 100,
TimeSpan.FromSeconds(15));
await bufferController.PushPackets(audioPackets1);
await bufferController.PullPackets(audioPackets1);
SpinWait.SpinUntil(() => eventOnCount == 1, TimeSpan.FromSeconds(2));
await bufferController.PushPackets(audioPackets2);
SpinWait.SpinUntil(() => eventOnCount > 0 && eventOffCount > 0, TimeSpan.FromSeconds(2));
Assert.IsTrue(eventOffCount == 1, $"Expected: eventOffCount==1 Result eventOffCount=={eventOffCount}");
Assert.IsTrue(eventOnCount == 1, $"Expected: eventOnCount==1 Result eventOnCount=={eventOnCount}");
await audioPackets1.DisposePackets();
await audioPackets2.DisposePackets();
}
}
});
}
public void BufferOnEventFromMultipleSources()
{
Assert.DoesNotThrowAsync(
async() =>
{
using (var bufferController = new StreamBufferController(Observable.Return <PlayerState>(PlayerState.Playing)))
{
bufferController.Initialize(StreamType.Audio);
bufferController.Initialize(StreamType.Video);
var eventCount = 0;
var eventOnCount = 0;
using (bufferController.BufferingStateChanged()
.Subscribe(a =>
{
eventCount++;
if (a)
{
eventOnCount++;
}
}, SynchronizationContext.Current))
{
var audio = BuildPacketList(StreamType.Audio, TimeSpan.FromSeconds(15), 100);
var video = BuildPacketList(StreamType.Video, TimeSpan.FromSeconds(15), 100);
await Task.WhenAll(
bufferController.PushPackets(audio),
bufferController.PushPackets(video)
);
await Task.WhenAll(
bufferController.PullPackets(audio),
bufferController.PullPackets(video)
);
SpinWait.SpinUntil(() => eventOnCount > 0 && eventCount > 0, TimeSpan.FromSeconds(2));
Assert.IsTrue(eventCount > 0, $"Expected: eventCount > 0 Result: eventCount=={eventCount}");
Assert.IsTrue(eventOnCount > 0, $"Expected: eventOnCount > 0 Result: eventOnCount=={eventOnCount}");
await Task.WhenAll(
audio.DisposePackets(),
video.DisposePackets()
);
}
}
});
}
public EsStreamController(EsPlayerPacketStorage storage, Window window)
{
displayWindow = window;
CreatePlayer();
packetStorage = storage;
// Create placeholder to data streams & chunk states
esStreams = new EsStream[(int)StreamType.Count];
streamReconfigureSubs = new IDisposable[(int)StreamType.Count];
playbackErrorSubs = new IDisposable[(int)StreamType.Count];
bufferController = new StreamBufferController(stateChangedSubject);
AttachEventHandlers();
}
public EsStream(Common.StreamType type, EsPlayerPacketStorage storage, StreamBufferController bufferController)
{
streamType = type;
packetStorage = storage;
streamBufferController = bufferController;
switch (streamType)
{
case StreamType.Audio:
PushStreamConfig = PushAudioConfig;
break;
case StreamType.Video:
PushStreamConfig = PushVideoConfig;
break;
default:
throw new ArgumentException($"Stream Type {streamType} is unsupported");
}
wakeup = new ManualResetEventSlim(false);
barrier = new PacketBarrier(TransferChunk);
}
