private bool CalculateRatio(AudioParam input)
{
if (!CompatibleAudioRenderer)
return false;
var stats = Player.Stats.Details;
if (stats == null)
return false;
var videoInterval = Media.VideoInfo.AvgTimePerFrame;
if (videoInterval < 1e-8)
return false; // audio only - no need to reclock
var refclk = stats.RefClockDeviation;
var hasRefClk = refclk > -10 && refclk < 10;
if (!hasRefClk)
return false;
const int oneSecond = 1000000;
var videoHz = oneSecond/videoInterval;
var displayHz = oneSecond/stats.DisplayRefreshIntervalUsec;
var ratio = displayHz/videoHz;
if (ratio > (100 + MAX_PERCENT_ADJUST)/100 || ratio < (100 - MAX_PERCENT_ADJUST)/100)
return false;
CalculateRatio(input, ratio, refclk, videoHz, displayHz);
return true;
}
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);
}
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 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 AudioSave Copy()
{
AudioSave a = new AudioSave();
foreach (var item in AudioParam)
{
AudioParam ap = new AudioParam();
ap.name = item.name;
ap.value = item.value;
a.AudioParam.Add(ap);
}
return(a);
}
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 override bool Process(AudioParam input, AudioParam output)
{
if (!CalculateRatio(input))
{
m_SampleIndex = -4*RATIO_ADJUST_INTERVAL;
m_Ratio = 1;
return false;
}
// Passthrough from input to output
AudioHelpers.CopySample(input.Sample, output.Sample, true);
PerformReclock(output);
return true;
}
private DomainProcessedVideo CreateProcessedVideo(VideoParam videoParam, AudioParam audioParam, bool isVideoCopy, bool isAudioCopy, string contentType)
{
return new DomainProcessedVideo
{
VideoParam = videoParam,
AudioParam = audioParam,
IsVideoCopy = isVideoCopy,
IsAudioCopy = isAudioCopy,
OutputFormat = String.Format("{0}x{1}", videoParam.MediaContainer, videoParam.VideoWidth),
ContentType = contentType,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
Started = DateTime.UtcNow,
Completed = DateTime.UtcNow
};
}
private DomainProcessedVideo CreateProcessedVideo(VideoParam videoParam, AudioParam audioParam, bool isVideoCopy, bool isAudioCopy, string contentType)
{
return(new DomainProcessedVideo
{
VideoParam = videoParam,
AudioParam = audioParam,
IsVideoCopy = isVideoCopy,
IsAudioCopy = isAudioCopy,
OutputFormat = String.Format("{0}x{1}", videoParam.MediaContainer, videoParam.VideoWidth),
ContentType = contentType,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
Started = DateTime.UtcNow,
Completed = DateTime.UtcNow
});
}
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 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 bool AudioParamCompare(AudioAdjusterParam audioAdjusterParam, AudioParam audioParam)
{
return audioAdjusterParam.AudioCodec == audioParam.AudioCodec
&& audioAdjusterParam.AudioBitrate == audioParam.AudioBitrate;
}
private void PerformReclock(AudioParam output)
{
long start, end;
output.Sample.GetTime(out start, out end);
long endDelta = end - start;
start = (long) (start*m_Ratio);
output.Sample.SetTime(start, endDelta);
}
private void CalculateRatio(AudioParam input, double ratio, double refclk, double videoHz, double displayHz)
{
var format = input.Format;
var bytesPerSample = format.wBitsPerSample/8;
var length = input.Sample.GetActualDataLength()/bytesPerSample;
m_SampleIndex += length;
if (m_SampleIndex < RATIO_ADJUST_INTERVAL)
return;
m_SampleIndex = 0;
// Fine tune further when we have refclk stats
var actualVideoHz = videoHz*(1 + refclk);
var finalDifference = displayHz/actualVideoHz;
// finalDifference will get smaller over time as refclk inches closer and closer to the target value
var overshoot = m_Sanear ? SANEAR_OVERSHOOT : DIRECTSOUND_OVERSHOOT;
var swing = Math.Pow(finalDifference, overshoot);
ratio *= Math.Max(1 - MAX_SWING, Math.Min(1 + MAX_SWING, swing));
// Let it overshoot the final difference so we can converge faster
// Sanear has a built-in low-pass filter that allows it to creep its sample rate towards the target
// so we need a much higher overshoot to make it converge faster
// DSound on the other hand doesn't
m_Ratio = ratio;
}
public bool AudioParamCompare(AudioAdjusterParam audioAdjusterParam, AudioParam audioParam)
{
return(audioAdjusterParam.AudioCodec == audioParam.AudioCodec &&
audioAdjusterParam.AudioBitrate == audioParam.AudioBitrate);
}
public void connect(AudioParam destination, int output)
{
}
