private void onJump()
{
_videoPacket = null;
onCache(true);
_cache.Start(_replayProcess.GetPlayingTime());
_replayProcess.UpdateCache(_guid, _replayProcess.GetPlayingTime());
}
private void onVideoStream(VideoStreamsPacket vsp)
{
if ((vsp.TimePeriod.BeginTime == DateTime.MinValue || vsp.TimePeriod.EndTime == DateTime.MinValue) && !_disposeEvent.WaitOne(1))
{
sendToGetVideoData();
Thread.Sleep(10);
return;
}
if (isValidPacket(vsp))
{
enqueue(vsp);
//等待下次缓存或结束
while (Count() >= MaxCache && !_disposeEvent.WaitOne(10))
{
}
//判断是否需要继续获取缓存数据。
if (!_disposeEvent.WaitOne(1))
{
changedNextTime();
//Console.WriteLine("接收：" + vsp.TimePeriod.BeginTime.TimeOfDay + " - " + vsp.TimePeriod.EndTime.TimeOfDay);
//Console.WriteLine("Packet Count: " + Count() + "\t Next Time: " + NextTime);
if (NextTime >= DataInfoModel.End)//下载完成,停止缓冲
{
//Console.WriteLine("下载缓冲完毕！");
return;
}
//有下一数据包时间。
sendToGetVideoData();
}
}
else
{
Console.WriteLine("无效的数据包!{0} - {1}", vsp.TimePeriod.BeginTime.TimeOfDay, vsp.TimePeriod.EndTime.TimeOfDay);
}
}
public void TestVideoStreamsPacket_CompareTo()
{
VideoStreamsPacket vp = newVideoStreamsPacket();
Assert.AreEqual(1, vp.CompareTo(null));
Assert.AreEqual(0, vp.CompareTo(vp));
}
private void onVideoPacket(VideoStreamsPacket packet)
{
var handler = VideoDataReceived;
if (handler != null)
{
handler(packet);
}
}
private void onVideoPacketReceived(VideoStreamsPacket packet)
{
var handle = VideoStreamEvent;
if (handle != null)
{
handle(packet);
}
}
bool isValidPacket(VideoStreamsPacket vsp)
{
if (vsp?.TimePeriod != null)
{
if (vsp.TimePeriod.IsInRange(NextTime)) //防止数据重复下载，保证数据有效性
{
return(true);
}
}
return(false);
}
private async void onVideoStreams(VideoStreamsPacket packet)
{
await Task.Yield();
var handle = VideoStreamsReceived;
if (handle != null)
{
handle(packet);
}
}
private void playByTime(DateTime time)
{
try
{
onCache(noAnyValidFrameStream(time));
updateHaveDataFromTimePeriods(time);
while (!_disposeEvent.WaitOne(0))
{
while (needToNextPacket(time) && _cache.Count() > 0)
{
_videoPacket = _cache.DequeuePacket();
//Console.WriteLine("{0} \t {1}\t{2}", _guid.ToString(), _videoPacket.TimePeriod.BeginTime.TimeOfDay, _videoPacket.TimePeriod.EndTime.TimeOfDay);
_packetIndex = 0;
}
if (_videoPacket == null)
{
return;
}
int index = _packetIndex;
if (_packetIndex < _videoPacket.VideoStreams.Length)
{
var stream = _videoPacket.VideoStreams.ElementAt(_packetIndex);
if (stream.Time <= time)
{
lock (_obj)
{
if (_decoder != null)
{
_decoder.Update(stream);
_packetIndex++;
//if (_decoder.Update(stream))
// _packetIndex++;
//else
// Console.WriteLine("缓冲区已满，需要重复送入数据!");
}
}
//Console.WriteLine("Stream: {0} \t{1}\t{2}", stream.Time.TimeOfDay, stream.Type, stream.Buffer.Length);
}
else
{
return;
}
}
if (index == _packetIndex)
{
Thread.Sleep(1);
}
}
}
catch (Exception ex) {
Console.WriteLine("playByTime error! \n" + ex.ToString());
}
}
private void onVideoStream(VideoStreamsPacket packet)
{
if (_recorder.Set(packet))
{
updateFromDownloadedStatus();
onTimePeriodPacket();
if (isStatus(DownloadStatus.Downloading))
{
getVideoPacket();
}
}
}
private void getVideoStreamsPacket(VideoDataParam videoDataParam)
{
VideoStreamsPacket packet = _download?.GetVideoStreamsPacket(videoDataParam.Time);
if (packet != null)
{
send(ParamCode.VideoPacket, VideoStreamsPacket.Encode(packet));
}
else
{
send(ParamCode.VideoPacket, new byte[0]);
}
}
private byte[] getVideoPacketBuffer(VideoDataParam param)
{
VideoStreamsPacket packet = StorageDownloader.Instance.GetVideoPacket(param.VideoId, param.StreamId, param.Time);
if (packet != null)
{
return(VideoStreamsPacket.Encode(packet));
}
else
{
return(new byte[0]);
}
}
private static void assertEquals(DateTime time, VideoStreamsPacket packet)
{
Assert.IsNotNull(packet);
Assert.AreEqual(5, packet.VideoStreams.Length);
Assert.AreEqual(DataType.StreamDataKey, packet.VideoStreams[0].Type);
Assert.AreEqual(1920 * 1080 * 3, packet.VideoStreams[0].Buffer.Length);
Assert.AreEqual(time, packet.VideoStreams[0].Time);
for (int i = 1; i < 5; i++)
{
Assert.AreEqual(DataType.StreamData, packet.VideoStreams[i].Type);
Assert.AreEqual(100000, packet.VideoStreams[i].Buffer.Length);
Assert.AreEqual(time.AddSeconds(i), packet.VideoStreams[i].Time);
}
}
private void update(VideoStreamsPacket info)
{
if (_endTime != info.TimePeriod.BeginTime)
{
stopSign();
}
for (int i = 0; i < info.VideoStreams.Length; i++)
{
_recorder.Set(info.VideoStreams[i]);
}
_recorder.FinishPackage(info.TimePeriod.EndTime);
_endTime = info.TimePeriod.EndTime;
_downloadProgress.Download(info.TimePeriod);
}
private static void assertVideoStreams(int expLength, DateTime beginTime, VideoStreamsPacket vp)
{
Assert.IsNotNull(vp);
Assert.AreEqual(beginTime, vp.TimePeriod.BeginTime);
Assert.AreEqual(beginTime.AddMinutes(expLength), vp.TimePeriod.EndTime);
Assert.AreEqual(expLength, vp.VideoStreams.Length);
Assert.AreEqual(beginTime, vp.VideoStreams[0].Time);
Assert.AreEqual(DataType.StreamDataKey, vp.VideoStreams[0].Type);
Assert.AreEqual(6, vp.VideoStreams[0].Buffer.Length);
for (int i = 1; i < expLength; i++)
{
Assert.AreEqual(beginTime.AddMinutes(i), vp.VideoStreams[i].Time);
Assert.AreEqual(DataType.StreamData, vp.VideoStreams[i].Type);
Assert.AreEqual(3, vp.VideoStreams[i].Buffer.Length);
}
}
public void TestDownloadRecorder()
{
string path = "D:\\读写测试\\TestDownloadRecorder";
StreamPacket[] sPackets = Recorder(path);
VideoStreamsPacket packet = FolderManager.GetVideoStreamsPacket(path, sPackets.First(_ => _.Type == DataType.StreamDataKey).Time.AddSeconds(1));
Assert.AreEqual(sPackets.First(_ => _.Type == DataType.StreamDataKey).Time, packet.TimePeriod.BeginTime);
Assert.AreEqual(sPackets.Last().Time.AddSeconds(1), packet.TimePeriod.EndTime);
Assert.AreEqual(5, packet.VideoStreams.Length);
for (int i = 0; i < packet.VideoStreams.Length; i++)
{
assertAreEqual(sPackets[i + 2], packet.VideoStreams[i]);
}
FolderManager.DeleteDirectoryInfo(path);
}
public void TestVideoStreamsPacket_Encode()
{
VideoStreamsPacket vp = newVideoStreamsPacket();
byte[] buffer = VideoStreamsPacket.Encode(vp);
VideoStreamsPacket decodeVp = VideoStreamsPacket.Decode(buffer);
Assert.AreEqual(ti.BeginTime, decodeVp.TimePeriod.BeginTime);
Assert.AreEqual(ti.EndTime, decodeVp.TimePeriod.EndTime);
Assert.AreEqual(sps.Count, vp.VideoStreams.Length);
for (int i = 0; i < sps.Count; i++)
{
Assert.AreEqual(sps[i].Time, vp.VideoStreams[i].Time);
Assert.AreEqual(sps[i].Type, vp.VideoStreams[i].Type);
Assert.AreEqual(sps[i].Buffer.Length, vp.VideoStreams[i].Buffer.Length);
}
}
private void Client_ReceiveCompleted(object sender, ReceiveEventArgs args)
{
try
{
if (args.ByteLength > 0)
{
onBytesLengthReceived(args.ByteLength);
using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
{
int code = PacketBase.ReadInt(ms);
switch ((ParamCode)code)
{
case ParamCode.TimePeriods:
onVideoStoragePacket(VideoTimePeriodsPacket.Decode(ms));
break;
case ParamCode.VideoPacket:
onVideoPacket(VideoStreamsPacket.Decode(ms));
break;
case ParamCode.VideoBaseInfo:
onVideoBasePacket(VideoBasePacket.Decode(ms));
break;
case ParamCode.DownloadInfosAll:
onDownloadInfosAll(DownloadInfoExpandPacket.DecodeArray(ms));
break;
case ParamCode.DownloadInfosAdd:
onDownloadInfosAdd(DownloadInfoExpandPacket.Decode(ms));
break;
case ParamCode.DownloadInfoPart:
onDownloadInfoPart(DownloadInfoPartConverter.Decode(ms));
break;
}
}
}
}
catch (Exception ex)
{
onException(ex);
}
}
public void TestVideoStoragerManager_GetVideoPacket()
{
var beginTime = new DateTime(2016, 3, 22, 23, 50, 1, 156);
Assert.IsNull(VideoStoragerManager.GetVideoPacket("videoId_21 111", 2, new DateTime()));
Assert.IsNull(VideoStoragerManager.GetVideoPacket("videoId", 2, beginTime));
VideoStreamsPacket vp = VideoStoragerManager.GetVideoPacket("videoId", 2, beginTime.AddMinutes(1));
assertVideoStreams(1, beginTime.AddMinutes(1), vp);
VideoStreamsPacket vp2 = VideoStoragerManager.GetVideoPacket("videoId", 2, beginTime.AddMinutes(3));
assertVideoStreams(2, beginTime.AddMinutes(2), vp2);
VideoStreamsPacket vp3 = VideoStoragerManager.GetVideoPacket("videoId", 2, beginTime.AddMinutes(5));
assertVideoStreams(3, beginTime.AddMinutes(4), vp3);
}
public bool Set(VideoStreamsPacket info)
{
lock (_lockObj)
{
if (_recorder != null && info != null)
{
if (_downloadProgress.IsValidTime(info.TimePeriod))
{
update(info);
if (IsDownloaded)
{
stopSign();
}
return(true);
}
}
}
return(false);
}
private void onReceived(object sender, ReceiveEventArgs args)
{
if (args.ByteLength > 0)
{
using (MemoryStream ms = new MemoryStream(args.ReceivedBytes))
{
int code = PacketBase.ReadInt(ms);
//Console.WriteLine("{0} - {1}", (ParamCode)code, args.ByteLength);
switch ((ParamCode)code)
{
case ParamCode.TimePeriods:
//接收所有有效视频分布
onTimePeriodsAll(VideoTimePeriodsPacket.Decode(ms).TimePeriods);
break;
case ParamCode.VideoBaseInfo:
//设置视频基本信息
onVideoBase(VideoBasePacket.Decode(ms));
break;
case ParamCode.DownloadProgress:
//接收推送的下载进度。
onTimePeriodsDownloaded(VideoTimePeriodsPacket.Decode(ms).TimePeriods);
break;
case ParamCode.VideoPacket:
//接收视频包数据流
onVideoStreams(VideoStreamsPacket.Decode(ms));
break;
case ParamCode.LocalDownloadPath:
onDownloadPathReceived(PacketBase.ReadString(ms));
break;
case ParamCode.Message:
onVideoMessageFeedback(MessagePacket.Decode(ms));
break;
}
}
}
}
private void enqueue(VideoStreamsPacket vsp)
{
lock (_vsQueue)
_vsQueue.Enqueue(vsp);
LastestTime = vsp.TimePeriod.EndTime;
}
