private async Task ProcessFile(string file)
{
StreamReader stream = null;
try
{
var tracking = new Host("FTP", IPAddress.Loopback);
var header = new VideoHeader(tracking, file);
if (!destination.IsDownloaded(header))
{
log.Info("Copy <{0}>", file);
stream = new StreamReader(file);
await destination.Transfer(header, stream.BaseStream).ConfigureAwait(false);
}
else
{
log.Info("File is already copied <{0}", file);
}
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
stream?.Dispose();
}
}
public bool IsDownloaded(VideoHeader header)
{
Guard.NotNull(() => header, header);
var fileDestination = header.GetPath(destination);
return(File.Exists(fileDestination));
}
public async Task Transfer(VideoHeader header, Stream source)
{
Guard.NotNull(() => header, header);
Guard.NotNull(() => source, source);
var temp = Path.GetTempFileName();
using (StreamWriter write = new StreamWriter(temp))
{
await source.CopyToAsync(write.BaseStream).ConfigureAwait(false);
}
try
{
using (VideoFileReader reader = new VideoFileReader())
{
reader.Open(temp);
using (Bitmap videoFrame = reader.ReadVideoFrame())
{
videoFrame.Save(ResolveName(header), ImageFormat.Png);
}
}
}
finally
{
File.Delete(temp);
}
}
protected override bool GetLiveFrameInternal(TimeSpan timeout, out BaseDataHeader header, out byte[] data)
{
header = null;
data = null;
// TODO: Implement request for fetching data from device
if (data == null || data.Length == 0)
{
return(false);
}
DateTime dt = DateTime.UtcNow; // TODO: If a timestamp is provided by device, use that instead
// TODO: Update to reflect actual data
header = new VideoHeader()
{
CodecType = VideoCodecType.JPEG,
Length = (ulong)data.Length,
SequenceNumber = _sequence++,
SyncFrame = true,
TimestampSync = dt,
TimestampFrame = dt
};
return(true);
}
protected override bool GetLiveFrameInternal(TimeSpan timeout, out BaseDataHeader header, out byte[] data)
{
header = null;
data = _demoConnectionManager.GetLiveFrame(Channel, false);
if (data.Length == 0)
{
return(false);
}
DateTime dt = DateTime.UtcNow;
var codec = VideoCodecType.JPEG;
// If you wanted to support multiple codecs, the commented code below demonstrates how this could be done (and also how to get stream settings for any other purpose)
// var setting = _settingsManager.GetSetting(new StreamSetting(Constants.Codec, _deviceId, _streamId, ""));
// if (setting.Value == VideoCodecType.H264.ToString())
// {
// codec = VideoCodecType.H264;
// }
// For video codec types other than JPEG, an important thing to note here is that we always transfer the data out of the GetLiveFrame
// call in single frame chunks. That is to say, regardless of what kind of frame it might be (P-frame, I-frame, etc.) it is sent as
// one frame per message.
header = new VideoHeader()
{
CodecType = codec,
Length = (ulong)data.Length,
SequenceNumber = _sequence++,
SyncFrame = true, // For codecs other than MJPEG, this should only be true for key frames.
TimestampSync = dt, // If the video codec is e.g. H.264, this should be the time stamp of the most recent keyframe. On a keyframe, this will be the same as TimestampFrame.
TimestampFrame = dt
};
return(true);
}
public void GetPath(string fileName, string expected)
{
VideoHeader header = new VideoHeader(new Host("Camera", IPAddress.Any), fileName);
var result = header.GetPath(@"c:\out");
Assert.AreEqual(expected, result);
}
public void SetUp()
{
header = new VideoHeader(new Host("Camera", IPAddress.Any), "test.mov");
mockDestination = new Mock <IDestination>();
mockAction = new Mock <IPriorAction>();
stream = new Mock <Stream>();
instance = CreateChainedActionDestination();
}
private void HandleSearchSelectedItem(object listBox, object selectedItem)
{
VideoHeader selected = selectedItem as VideoHeader;
CurrentMediaSource.VideoSource = StatisticsActionSource.search;
CurrentMediaSource.VideoContext = this._searchQuery;
this.ProcessSelectedVideoHeader(selected);
}
public void SetUp()
{
header = new VideoHeader(new Host("Test", IPAddress.Any), "test.mov");
mockDestination = new Mock <IDestination>();
renameFunc = name => "test";
stream = new Mock <Stream>();
instance = CreateTransformedDestination();
}
private void ProcessSelectedVideoHeader(VideoHeader selected)
{
if (selected == null)
{
return;
}
Navigator.Current.NavigateToVideoWithComments(selected.VKVideo, selected.VKVideo.owner_id, selected.VKVideo.vid, "");
}
public override async Task Transfer(VideoHeader header, Stream source)
{
Guard.NotNull(() => header, header);
Guard.NotNull(() => source, source);
var transfer = next.Transfer(header, source);
var name = next.ResolveName(header);
await transfer.ConfigureAwait(false);
await postAction.AfterTransfer(name).ConfigureAwait(false);
}
public async Task Transfer(VideoHeader header, Stream source)
{
Guard.NotNull(() => header, header);
Guard.NotNull(() => source, source);
var fileDestination = ResolveName(header);
using (StreamWriter write = new StreamWriter(fileDestination))
{
await source.CopyToAsync(write.BaseStream).ConfigureAwait(false);
}
}
public override async Task Transfer(VideoHeader header, Stream source)
{
Guard.NotNull(() => header, header);
Guard.NotNull(() => source, source);
var result = await priorAction.BeforeTransfer(header, source).ConfigureAwait(false);
using (result.source)
{
await next.Transfer(result.header, result.source).ConfigureAwait(false);
}
}
private void Video_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
VideoHeader selectedItem = this.videosListBox.SelectedItem as VideoHeader;
if (selectedItem == null)
{
return;
}
this.videosListBox.SelectedItem = null;
Navigator.Current.NavigateToVideoWithComments(selectedItem.VKVideo, selectedItem.VKVideo.owner_id, selectedItem.VKVideo.vid, selectedItem.VKVideo.access_key ?? "");
}
public async Task Transfer()
{
VideoHeader inpuParameter = null;
mockDestination.Setup(item => item.Transfer(It.IsAny <VideoHeader>(), stream.Object)).Returns(Task.CompletedTask)
.Callback <VideoHeader, Stream>(
(parameter, inputStream) => { inpuParameter = parameter; });
await instance.Transfer(header, stream.Object);
Assert.AreEqual("test", inpuParameter.FileName);
}
public void SetUp()
{
outPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "out");
if (Directory.Exists(outPath))
{
Directory.Delete(outPath, true);
}
header = new VideoHeader(new Host("Camera", IPAddress.Any), "test.mov");
instance = CreatePictureFileDestination();
stream = File.OpenRead(Path.Combine(TestContext.CurrentContext.TestDirectory, "data", "centaur_1.mpg"));
}
public void ChangeExtension()
{
VideoHeader inpuParameter = null;
mockDestination.Setup(item => item.ResolveName(It.IsAny <VideoHeader>())).Returns("test")
.Callback <VideoHeader>(
parameter => { inpuParameter = parameter; });
var result = TransformedDestination.ChangeExtension(mockDestination.Object, "png");
result.ResolveName(header);
Assert.AreEqual("test.png", inpuParameter.FileName);
}
public void IsDownloaded()
{
VideoHeader inpuParameter = null;
mockDestination.Setup(item => item.IsDownloaded(It.IsAny <VideoHeader>())).Returns(true)
.Callback <VideoHeader>(
parameter => { inpuParameter = parameter; });
var result = instance.IsDownloaded(header);
Assert.IsTrue(result);
Assert.AreEqual("test", inpuParameter.FileName);
}
public void ResolveName()
{
VideoHeader inpuParameter = null;
mockDestination.Setup(item => item.ResolveName(It.IsAny <VideoHeader>())).Returns("test")
.Callback <VideoHeader>(
parameter => { inpuParameter = parameter; });
var name = instance.ResolveName(header);
Assert.AreEqual("test", name);
Assert.AreEqual("test", inpuParameter.FileName);
}
public async Task Transfer()
{
Assert.IsFalse(File.Exists(outFile));
VideoHeader header = new VideoHeader(new Host("Camera", IPAddress.Any), "test.txt");
using (StreamReader reader = new StreamReader(Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "Test.txt")))
{
await instance.Transfer(header, reader.BaseStream).ConfigureAwait(false);
}
Assert.IsTrue(File.Exists(outFile));
}
public void SetUp()
{
header = new VideoHeader(new Host("Camera", IPAddress.Any), "test.mov");
outPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Out");
if (Directory.Exists(outPath))
{
Directory.Delete(outPath, true);
}
instance = CreateFileDestination();
stream = new MemoryStream(new byte[] { 1 });
}
public override PlaybackReadResponse ReadData(Guid playbackId)
{
DateTime cur;
lock (_playbackLockObj)
{
if (!_playbackCursors.TryGetValue(playbackId, out cur))
{
throw new KeyNotFoundException(nameof(playbackId));
}
}
try
{
// TODO: request real data
byte[] data = new byte[] { };
if (data == null)
{
Toolbox.Log.Trace("--- No data returned ");
return(null);
}
// TODO: Change to correct values - potentially different codec.
VideoHeader jpegHeader = new VideoHeader();
jpegHeader.CodecType = VideoCodecType.JPEG;
jpegHeader.SyncFrame = true;
PlaybackFrame frame = new PlaybackFrame()
{
Data = data, Header = jpegHeader, AnyMotion = true
};
jpegHeader.SequenceNumber = 0;
jpegHeader.Length = (ulong)data.Length;
jpegHeader.TimestampFrame = cur;
jpegHeader.TimestampSync = cur;
DateTime prev = cur - TimeSpan.FromSeconds(1);
DateTime next = cur + TimeSpan.FromSeconds(1);
return(new PlaybackReadResponse()
{
SequenceNumber = _sequenceNumbers[playbackId],
Next = next,
Previous = prev,
Frames = new[] { frame },
});
}
catch (Exception e)
{
Toolbox.Log.Trace("{0}: Exception={1}", nameof(ReadData), e.Message + e.StackTrace);
return(null);
}
}
private async Task ProcessFile(FtpClient client, FtpListItem item)
{
Stream stream = null;
try
{
var header = new VideoHeader(tracking.Host, item.FullName);
if (!destination.IsDownloaded(header))
{
log.Info("Downloading <{0}> from [{1}]", item.FullName, tracking.Host.Name);
stream = await client.OpenReadAsync(item.FullName).ConfigureAwait(false);
await destination.Transfer(header, stream).ConfigureAwait(false);
var reply = await client.GetReplyAsync(CancellationToken.None).ConfigureAwait(false);
if (reply.Success)
{
log.Info(
"Download Success:{0} Message:{1}: Type:{2} Code:{3} From: [{4}]",
reply.Success,
reply.Message,
reply.Type,
reply.Code,
tracking.Host.Name);
}
else
{
log.Error(
"Download Error:{0} Type:{1}: Code:{2} From: [{3}]",
reply.ErrorMessage,
reply.Type,
reply.Code,
tracking.Host.Name);
}
}
else
{
log.Info("File is already downloaded - <{0}> {1}", item.FullName, tracking.Host.Name);
}
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
stream?.Dispose();
}
}
public Task <(VideoHeader header, Stream source)> BeforeTransfer(VideoHeader header, Stream source)
{
Guard.NotNull(() => header, header);
Guard.NotNull(() => source, source);
var memory = new MemoryStream();
ZipArchive archive = new ZipArchive(memory, ZipArchiveMode.Create, true);
ZipArchiveEntry readmeEntry = archive.CreateEntry(Path.GetFileName(header.FileName));
using (Stream entryStream = readmeEntry.Open())
{
source.CopyTo(entryStream);
}
memory.Position = 0;
return(Task.FromResult((header, (Stream)memory)));
}
public THP_Parser(Stream stream)
{
using (var reader = new FileReader(stream, true))
{
reader.SetByteOrder(true);
FileHeader = reader.ReadStruct <Header>();
bool isVersion11 = FileHeader.Version == 0x00011000;
reader.SeekBegin(FileHeader.ComponentsOffset);
uint numComponents = reader.ReadUInt32();
byte[] components = reader.ReadBytes(16);
for (int i = 0; i < components.Length; i++)
{
if (components[i] == (byte)ComponentType.Video)
{
Video = new VideoHeader(reader, isVersion11);
}
if (components[i] == (byte)ComponentType.Audio)
{
Audio = new AudioHeader(reader, isVersion11);
}
}
bool hasVideo = components.Any(x => x == (byte)ComponentType.Video);
bool hasAudio = components.Any(x => x == (byte)ComponentType.Audio);
reader.SeekBegin(FileHeader.FirstFrameOffset);
for (int i = 0; i < FileHeader.FrameCount; i++)
{
long startFrame = reader.Position;
var frame = new FrameHeader(reader, hasAudio ? Audio.NumChannels : 0);
Frames.Add(frame);
if (i == 0)
{
reader.SeekBegin(startFrame + FileHeader.FirstFrameLength);
}
else
{
reader.SeekBegin(startFrame + Frames[i - 1].NextFrameSize);
}
}
}
}
private void GoToMessage_OnClicked(object sender, RoutedEventArgs e)
{
long message_id = 0;
object dataContext = ((FrameworkElement)sender).DataContext;
switch (this.pivot.SelectedIndex)
{
case 0:
AlbumPhoto albumPhoto = dataContext as AlbumPhoto;
message_id = albumPhoto != null ? albumPhoto.MessageId : 0L;
break;
case 1:
VideoHeader videoHeader = dataContext as VideoHeader;
message_id = videoHeader != null ? videoHeader.MessageId : 0L;
break;
case 2:
AudioHeader audioHeader = dataContext as AudioHeader;
message_id = audioHeader != null ? audioHeader.MessageId : 0L;
break;
case 3:
DocumentHeader documentHeader = dataContext as DocumentHeader;
message_id = documentHeader != null ? documentHeader.MessageId : 0L;
break;
case 4:
LinkHeader linkHeader = dataContext as LinkHeader;
message_id = linkHeader != null ? linkHeader.MessageId : 0L;
break;
}
if (message_id == 0L)
{
return;
}
long peerId = this.ViewModel.PeerId;
if (this.ViewModel.IsChat)
{
peerId -= 2000000000L;
}
Navigator.Current.NavigateToConversation(peerId, this.ViewModel.IsChat, false, "", message_id, false);
}
private void ProcessSelectedVideoHeader(VideoHeader selected)
{
if (selected == null)
{
return;
}
if (!this.CommonParameters.PickMode)
{
Navigator.Current.NavigateToVideoWithComments(selected.VKVideo, selected.VKVideo.owner_id, selected.VKVideo.vid, "");
}
else
{
ParametersRepository.SetParameterForId("PickedVideo", selected.VKVideo);
if (this._albumId != 0L)
{
((Page)this).NavigationService.RemoveBackEntrySafe();
}
Navigator.Current.GoBack();
}
}
protected override bool GetLiveFrameInternal(TimeSpan timeout, out BaseDataHeader header, out byte[] data)
{
header = null;
data = _connectionManager.PopFrame();
if (data == null || data.Length == 0)
{
return(false);
}
DateTime dt = DateTime.UtcNow;
header = new VideoHeader
{
CodecType = VideoCodecType.JPEG,
Length = (ulong)data.Length,
SequenceNumber = _sequence++,
SyncFrame = true,
TimestampSync = dt,
TimestampFrame = dt
};
return(true);
}
public string ResolveName(VideoHeader header)
{
Guard.NotNull(() => header, header);
return(next.ResolveName(header));
}
public bool IsDownloaded(VideoHeader header)
{
Guard.NotNull(() => header, header);
return(next.IsDownloaded(header));
}