public void CreateProcessedVideosTest()
{
//Arrange
const string newContainer = "newContainer";
const string contentType = "contentType";
var processedVideoBuilder = new Mock <IProcessedVideoBuilder>();
var processedVideoList = new ProcessedVideoList(processedVideoBuilder.Object);
var videoParam = new VideoAdjusterParam();
var audioParam = new AudioAdjusterParam();
var processedVideo1 = new DomainProcessedVideo();
var processedVideo2 = new DomainProcessedVideo();
var size1 = new Mock <IVideoSize>();
var size2 = new Mock <IVideoSize>();
var sizeList = new List <IVideoSize> {
size1.Object, size2.Object
};
processedVideoBuilder.Setup(m => m.BuildProcessedVideo(videoParam, audioParam, newContainer, size1.Object, contentType)).Returns(processedVideo1);
processedVideoBuilder.Setup(m => m.BuildProcessedVideo(videoParam, audioParam, newContainer, size2.Object, contentType)).Returns(processedVideo2);
//Act
IEnumerable <DomainProcessedVideo> list = processedVideoList.CreateProcessedVideos(videoParam, audioParam, newContainer, sizeList, contentType);
//Assert
Assert.AreEqual(sizeList.Count, list.Count());
Assert.IsTrue(list.Any(p => p == processedVideo1));
Assert.IsTrue(list.Any(p => p == processedVideo1));
}
public void Initialize()
{
const string mediaContainer = "mediaContainer";
const string videoCodec = "videoCodec";
const string videoProfile = "videoProfile";
const int videoBitrate = 10000;
const int width = 150;
const int height = 100;
const double frameRate = 25;
const int keyFrameRate = 10;
const string audioCodec = "audioCodec";
const int audioBitrate = 500;
_comparator = new Comparator();
_videoSize = new VideoSize(width, height);
_videoAdjusterParam = new VideoAdjusterParam()
{
MediaContainer = mediaContainer,
VideoCodec = videoCodec,
VideoProfile = videoProfile,
VideoBitrate = videoBitrate,
FrameRate = frameRate,
KeyFrameRate = keyFrameRate
};
_videoParam = new VideoParam()
{
MediaContainer = mediaContainer,
VideoCodec = videoCodec,
VideoProfile = videoProfile,
VideoBitrate = videoBitrate,
VideoWidth = width,
VideoHeight = height,
FrameRate = frameRate,
KeyFrameRate = keyFrameRate
};
_audioAdjusterParam = new AudioAdjusterParam()
{
AudioCodec = audioCodec,
AudioBitrate = audioBitrate
};
_audioParam = new AudioParam()
{
AudioCodec = audioCodec,
AudioBitrate = audioBitrate
};
}
public AudioParam AdjustAudioParam(AudioAdjusterParam audioAdjusterParam, string mediaContainer, IVideoSize videoSize)
{
var exceptionList = new List <VideoFormatException>();
int size = videoSize.Square();
string audioCodec = AdjustAudioCodec(mediaContainer, audioAdjusterParam.AudioCodec, audioAdjusterParam.IsExistAudioStream, exceptionList);
int audioBitrate = AdjustAudioBitrate(size, audioAdjusterParam.AudioChannels, audioAdjusterParam.AudioBitrate, audioAdjusterParam.AudioSampleRate, audioAdjusterParam.IsExistAudioStream,
exceptionList);
CheckForException(exceptionList);
AudioParam adjustaudioParam = CreateParam(audioCodec, audioBitrate);
return(adjustaudioParam);
}
public void Initialize()
{
_audioParam = new AudioAdjusterParam()
{
AudioBitrate = 567,
AudioCodec = "audioCodec",
AudioChannels = 2,
IsExistAudioStream = true,
AudioSampleRate = 123
};
_adjustmentAudioParam = new Mock <IAdjustmentAudioMetadata>();
_audioAdjuster = new AudioAdjuster(_adjustmentAudioParam.Object);
}
public List <DomainProcessedVideo> Generate(IVideoMetadata videoMetadata)
{
int width = videoMetadata.VideoWidth;
int height = videoMetadata.VideoHeight;
List <IVideoSize> sizeList = _resolutionCalculator.Calculate(width, height);
VideoAdjusterParam videoParam = _multimediaAdjusterParamFactory.CreateVideoParam(videoMetadata);
AudioAdjusterParam audioParam = _multimediaAdjusterParamFactory.CreateAudioParam(videoMetadata);
IEnumerable <DomainProcessedVideo> mp4ProcessedVideos = _processedVideoList.CreateProcessedVideos(videoParam, audioParam, MetadataConstant.Mp4Container, sizeList, ContentType.Mp4Content);
IEnumerable <DomainProcessedVideo> webmProcessedVideos = _processedVideoList.CreateProcessedVideos(videoParam, audioParam, MetadataConstant.WebmContainer, sizeList, ContentType.WebmContent);
var list = new List <DomainProcessedVideo>();
list.AddRange(mp4ProcessedVideos);
list.AddRange(webmProcessedVideos);
return(list);
}
public void BuildProcessedVideoTest()
{
//Arrange
const string newContainer = "newContainer";
const string contentType = "contentType";
const bool isVideoParamEquals = true;
const bool isAudioParamEquals = false;
const int videoWidth = 2134;
var videoAdjusterParam = new VideoAdjusterParam();
var audioAdjusterParam = new AudioAdjusterParam();
var videoParam = new VideoParam()
{
VideoWidth = videoWidth, MediaContainer = newContainer
};
var audioParam = new AudioParam();
var outputFormat = string.Format("{0}x{1}", videoParam.MediaContainer, videoParam.VideoWidth);
var videoSize = new Mock <IVideoSize>();
var videoParamAdjuster = new Mock <IVideoAdjuster>();
var audioParamAdjuster = new Mock <IAudioAdjuster>();
var comparator = new Mock <IComparator>();
videoParamAdjuster.Setup(m => m.AdjustVideoParam(videoAdjusterParam, newContainer, videoSize.Object)).Returns(videoParam);
audioParamAdjuster.Setup(m => m.AdjustAudioParam(audioAdjusterParam, newContainer, videoSize.Object)).Returns(audioParam);
comparator.Setup(m => m.VideoParamCompare(videoAdjusterParam, videoParam, newContainer, videoSize.Object)).Returns(isVideoParamEquals);
comparator.Setup(m => m.AudioParamCompare(audioAdjusterParam, audioParam)).Returns(isAudioParamEquals);
var builder = new ProcessedVideoBuilder(videoParamAdjuster.Object, audioParamAdjuster.Object, comparator.Object);
//Act
var processedVideo = builder.BuildProcessedVideo(videoAdjusterParam, audioAdjusterParam, newContainer, videoSize.Object, contentType);
//Assert
Assert.AreEqual(videoParam, processedVideo.VideoParam);
Assert.AreEqual(audioParam, processedVideo.AudioParam);
Assert.AreEqual(isVideoParamEquals, processedVideo.IsVideoCopy);
Assert.AreEqual(isAudioParamEquals, processedVideo.IsAudioCopy);
Assert.AreEqual(outputFormat, processedVideo.OutputFormat);
Assert.AreEqual(contentType, processedVideo.ContentType);
}
public void GenerateProcessedVedeoTest()
{
//Arrange
var calculator = new Mock <IResolutionCalculator>();
var paramFactory = new Mock <IMultimediaAdjusterParamFactory>();
var processedVideoList = new Mock <IProcessedVideoList>();
var processedVideoGenerator = new ProcessedVideoGenerator(calculator.Object, paramFactory.Object, processedVideoList.Object);
var videoParam = new VideoAdjusterParam();
var audioParam = new AudioAdjusterParam();
var sizeList = new List <IVideoSize>();
var mp4ProcessedVideos = new List <DomainProcessedVideo> {
new DomainProcessedVideo()
};
var webmProcessedVideos = new List <DomainProcessedVideo> {
new DomainProcessedVideo()
};
var metadata = new Mock <IVideoMetadata>();
metadata.Setup(p => p.VideoWidth).Returns(2345);
metadata.Setup(p => p.VideoHeight).Returns(345);
calculator.Setup(m => m.Calculate(metadata.Object.VideoWidth, metadata.Object.VideoHeight)).Returns(sizeList);
paramFactory.Setup(m => m.CreateVideoParam(metadata.Object)).Returns(videoParam);
paramFactory.Setup(m => m.CreateAudioParam(metadata.Object)).Returns(audioParam);
processedVideoList.Setup(m => m.CreateProcessedVideos(videoParam, audioParam, MetadataConstant.Mp4Container, sizeList, ContentType.Mp4Content)).Returns(mp4ProcessedVideos);
processedVideoList.Setup(m => m.CreateProcessedVideos(videoParam, audioParam, MetadataConstant.WebmContainer, sizeList, ContentType.WebmContent)).Returns(webmProcessedVideos);
//Act
List <DomainProcessedVideo> list = processedVideoGenerator.Generate(metadata.Object);
//Assert
Assert.AreEqual(mp4ProcessedVideos.Count + webmProcessedVideos.Count, list.Count);
Assert.IsTrue(mp4ProcessedVideos.All(p => list.Any(procVid => procVid == p)));
Assert.IsTrue(webmProcessedVideos.All(p => list.Any(procVid => procVid == p)));
}
public IEnumerable <DomainProcessedVideo> CreateProcessedVideos(VideoAdjusterParam videoAdjusterParam, AudioAdjusterParam audioAdjusterParam, string newContainer, List <IVideoSize> sizeList,
string contentType)
{
return(sizeList.Select(videoSize => _processedVideoBuilder.BuildProcessedVideo(videoAdjusterParam, audioAdjusterParam, newContainer, videoSize, contentType)));
}
public bool AudioParamCompare(AudioAdjusterParam audioAdjusterParam, AudioParam audioParam)
{
return(audioAdjusterParam.AudioCodec == audioParam.AudioCodec &&
audioAdjusterParam.AudioBitrate == audioParam.AudioBitrate);
}
public DomainProcessedVideo BuildProcessedVideo(VideoAdjusterParam videoAdjusterParam, AudioAdjusterParam audioAdjusterParam, string newContainer, IVideoSize videoSize, string contentType)
{
VideoParam videoParam = _videoAdjuster.AdjustVideoParam(videoAdjusterParam, newContainer, videoSize);
AudioParam audioParam = _audioAdjuster.AdjustAudioParam(audioAdjusterParam, newContainer, videoSize);
bool isVideoCopy = _comparator.VideoParamCompare(videoAdjusterParam, videoParam, newContainer, videoSize);
bool isAudioCopy = _comparator.AudioParamCompare(audioAdjusterParam, audioParam);
DomainProcessedVideo processedVideo = CreateProcessedVideo(videoParam, audioParam, isVideoCopy, isAudioCopy, contentType);
return(processedVideo);
}
