public void FailsWithMissingBitDepth()
{
var request = new AudioUtilityRequest
{
//BitDepth = 16,
TargetSampleRate = 22050,
Channels = new[] { 1, 2, 3, 4 },
//BandPass
};
var tester = new FfmpegRawPcmAudioUtilityTester();
TestHelper.ExceptionMatches <InvalidOperationException>(
() =>
{
tester.InvokeCheckRequestValid(
this.source,
MediaTypes.GetMediaType(this.source.Extension),
this.output,
MediaTypes.GetMediaType(this.output.Extension),
request);
},
"A BitDepth must be supplied");
}
public void FailsWithInvalidBitDepth()
{
var request = new AudioUtilityRequest
{
BitDepth = 64,
TargetSampleRate = 22050,
Channels = new[] { 1, 2, 3, 4 },
//BandPass
};
var tester = new FfmpegRawPcmAudioUtilityTester();
TestHelper.ExceptionMatches <BitDepthOperationNotImplemented>(
() =>
{
tester.InvokeCheckRequestValid(
this.source,
MediaTypes.GetMediaType(this.source.Extension),
this.output,
MediaTypes.GetMediaType(this.output.Extension),
request);
},
"Supplied bit depth of 64");
}
public void SegmentsMp3Correctly2Sox()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromMinutes(3) + TimeSpan.FromSeconds(20),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeMp3,
BitsPerSecond = 32000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
OffsetStart = TimeSpan.FromSeconds(15),
OffsetEnd = TimeSpan.FromMinutes(3) + TimeSpan.FromSeconds(35),
};
var util = TestHelper.GetAudioUtilitySox();
var source = TestHelper.GetAudioFile("Currawongs_curlew_West_Knoll_Bees_20091102-183000.mp3");
var output = PathHelper.GetTempFile(MediaTypes.ExtMp3);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public void SegmentsWavCorrectly5Master()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(90),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
OffsetStart = TimeSpan.FromSeconds(27),
OffsetEnd = TimeSpan.FromSeconds(117),
TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("FemaleKoala MaleKoala.wav");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public void SegmentsWavCorrectly6Shntool()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(93),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
//MixDownToMono = false,
//Channel = 2,
OffsetStart = TimeSpan.FromSeconds(27),
//TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtilityShntool();
var source = TestHelper.GetAudioFile("geckos.wav");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
// Non functional / not used / not tested - jkust an idea
private static string FormatChannelSelection(AudioUtilityRequest request)
{
throw new NotImplementedException();
// -map_channel [input_file_id.stream_specifier.channel_id|-1][:output_file_id.stream_specifier]
// each -map_channel corresponds to an **output** channel. order is important.
// -ac 1 is a general mix down to mono
var map = string.Empty;
if (request.Channels.NotNull())
{
// minus 1 because ffmpeg channel specification starts at zero but our specification starts at 1
map = string.Join(string.Empty, request.Channels.Select(c => $" -map_channel 0.0.{c - 1}"));
}
var mixDown = request.MixDownToMono.HasValue && request.MixDownToMono.Value;
if (mixDown)
{
// mix down to mono
map = " -ac 1";
}
return(map);
}
public static void SeparateChannels(
Arguments args,
FileInfo ipFile,
out double[] samplesL,
out double[] samplesR,
out double epsilon)
{
//you'd then use wavreader on the resulting preparedFile
//the channel select functionality does not currently exist in AnalyzeLongRecording. I need to add it.
var request = new AudioUtilityRequest
{
OffsetStart = args.StartOffset,
OffsetEnd = args.EndOffset,
TargetSampleRate = args.SamplingRate,
Channels = new[] { 1, 2 },
MixDownToMono = false,
};
var audioFile = AudioFilePreparer.PrepareFile(args.OpDir, ipFile, args.OutputMediaType, request, args.OpDir).TargetInfo.SourceFile;
var wavReader = new WavReader(audioFile);
var recording = new AudioRecording(wavReader);
samplesL = recording.WavReader.GetChannel(0);
samplesR = recording.WavReader.GetChannel(1);
epsilon = Math.Pow(0.5, recording.BitsPerSample - 1);
}
public void SegmentsWavpackCorrectly7Master()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromMinutes(10) + TimeSpan.FromSeconds(0),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("f969b39d-2705-42fc-992c-252a776f1af3_090705-0600.wv");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public void SegmentsWavpackCorrectly3Wavunpack()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(55),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 353000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = false,
OffsetStart = TimeSpan.FromSeconds(0),
OffsetEnd = TimeSpan.FromSeconds(55),
//SampleRate = 11025
};
var source = TestHelper.GetAudioFile("f969b39d-2705-42fc-992c-252a776f1af3_090705-0600.wv");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
TestHelper.GetAudioUtilityWavunpack().Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = TestHelper.GetAudioUtility().Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public static void Modify(
string filename,
AudioUtilityInfo sourceExpected,
AudioUtilityRequest request,
string outputMimeType,
AudioUtilityInfo outputExpected,
Action <AudioUtilityInfo, AudioUtilityInfo> additionalTests = null)
{
var source = PathHelper.GetTestAudioFile(filename);
var destExtension = MediaTypes.GetExtension(outputMimeType);
var outputFilename = Path.GetFileNameWithoutExtension(filename) + "_modified." + destExtension;
foreach (var util in new[] { TestHelper.GetAudioUtility() })
{
var dir = PathHelper.GetTempDir();
var output = new FileInfo(Path.Combine(dir.FullName, outputFilename));
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, outputMimeType, request);
var sourceInfo = util.Info(source);
TestHelper.CheckAudioUtilityInfo(sourceExpected, sourceInfo);
var outputInfo = util.Info(output);
var outputInfoText = GetDurationInfo(outputInfo);
additionalTests?.Invoke(sourceExpected, sourceInfo);
PathHelper.DeleteTempDir(dir);
}
}
/// <summary>
/// Prepare an audio file. This will be a single segment of a larger audio file, modified based on the analysisSettings.
/// </summary>
/// <param name="outputDirectory">
/// The analysis Base Directory.
/// </param>
/// <param name="source">
/// The source audio file.
/// </param>
/// <param name="outputMediaType">
/// The output Media Type.
/// </param>
/// <param name="startOffset">
/// The start Offset from start of entire original file.
/// </param>
/// <param name="endOffset">
/// The end Offset from start of entire original file.
/// </param>
/// <param name="targetSampleRateHz">
/// The target Sample Rate Hz.
/// </param>
/// <returns>
/// The prepared file. The returned FileSegment will have the targetFile and OriginalFileDuration set -
/// these are the path to the segmented file and the duration of the segmented file.
/// The start and end offsets will not be set.
/// </returns>
public async Task <FileSegment> PrepareFile(
DirectoryInfo outputDirectory,
string source,
string outputMediaType,
TimeSpan startOffset,
TimeSpan endOffset,
int targetSampleRateHz)
{
return(await Task.Run(() =>
{
FileInfo sourceFileInfo = source.ToFileInfo();
var request = new AudioUtilityRequest
{
OffsetStart = startOffset,
OffsetEnd = endOffset,
TargetSampleRate = targetSampleRateHz,
};
var preparedFile = AudioFilePreparer.PrepareFile(
outputDirectory,
sourceFileInfo,
outputMediaType,
request,
TempFileHelper.TempDir(),
oldFormat: this.useOldNamingFormat);
return new FileSegment(
preparedFile.TargetInfo.SourceFile,
preparedFile.TargetInfo.SampleRate.Value,
preparedFile.TargetInfo.Duration.Value);
}));
}
public void SegmentsMp3Correctly6Master()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(134.6),
SampleRate = 44100,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeMp3,
BitsPerSecond = 64000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = false,
Channels = 2.AsArray(),
OffsetStart = TimeSpan.FromSeconds(27),
TargetSampleRate = 44100,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("A French Fiddle Speaks.mp3");
var output = PathHelper.GetTempFile(MediaTypes.ExtMp3);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
/// <summary>
/// Prepare an audio file. This will be a single segment of a larger audio file,
/// modified based on the provided settings.
/// </summary>
/// <param name="outputDirectory">
/// The analysis Base Directory.
/// </param>
/// <param name="source">
/// The source audio file.
/// </param>
/// <param name="outputMediaType">
/// The output Media Type.
/// </param>
/// <param name="startOffset">
/// The start Offset from start of entire original file.
/// </param>
/// <param name="endOffset">
/// The end Offset from start of entire original file.
/// </param>
/// <param name="targetSampleRateHz">
/// The target Sample Rate Hz.
/// </param>
/// <returns>
/// The prepared file. The returned FileSegment will have the targetFile and OriginalFileDuration set -
/// these are the path to the segmented file and the duration of the segmented file.
/// The start and end offsets will not be set.
/// </returns>
public async Task <FileSegment> PrepareFile(
DirectoryInfo outputDirectory,
string source,
string outputMediaType,
TimeSpan startOffset,
TimeSpan endOffset,
int targetSampleRateHz)
{
throw new NotImplementedException();
var request = new AudioUtilityRequest
{
OffsetStart = startOffset,
OffsetEnd = endOffset,
TargetSampleRate = targetSampleRateHz,
};
var preparedFile = AudioFilePreparer.PrepareFile(
outputDirectory,
source.ToFileInfo(),
outputMediaType,
request,
TempFileHelper.TempDir());
return(new FileSegment(
preparedFile.TargetInfo.SourceFile,
preparedFile.TargetInfo.SampleRate.Value,
preparedFile.TargetInfo.Duration.Value));
}
private static string FormatChannelSelection(AudioUtilityRequest request)
{
/*
* Where a range of channels is specified, the channel numbers to the left and right of the hyphen are
* optional and default to 1 and to the number of input channels respectively. Thus
* sox input.wav output.wav remix −
* performs a mix-down of all input channels to mono.
*/
var remix = string.Empty;
var mixDown = request.MixDownToMono.HasValue && request.MixDownToMono.Value;
if (mixDown && request.Channels.NotNull())
{
// select a subset of channels
remix = "remix " + string.Join(",", request.Channels);
}
else if (mixDown)
{
// mix down to mono
remix = "remix -";
}
else if (request.Channels.NotNull())
{
// get channels but don't mix down
remix = "remix " + string.Join(" ", request.Channels);
}
return(remix);
}
public void SoxResamplingShouldBeDeterministic()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(60),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 352800,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
TargetSampleRate = 22050,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("CaneToad_Gympie_44100.wav");
var repeats = new double[5][];
for (int r = 0; r < repeats.Length; r++)
{
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output,
MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
TestHelper.CheckAudioUtilityInfo(expected, actual);
var reader = new WavReader(output);
TestHelper.WavReaderAssertions(reader, actual);
repeats[r] = reader.Samples;
File.Delete(output.FullName);
}
for (int i = 1; i < repeats.Length; i++)
{
Assert.AreEqual(repeats[0].Length, repeats[1].Length);
var totalDifference = 0.0;
for (int j = 0; j < repeats[0].Length; j++)
{
var delta = Math.Abs(repeats[i][j] - repeats[0][j]);
totalDifference += delta;
}
CollectionAssert.AreEqual(repeats[0], repeats[i], $"Repeat {i} was not identical to repeat 0. Total delta: {totalDifference}");
}
}
public void InvokeCheckRequestValid
(
FileInfo source,
string sourceMediaType,
FileInfo output,
string outputMediaType,
AudioUtilityRequest request)
{
this.CheckRequestValid(source, sourceMediaType, output, outputMediaType, request);
}
private void RunUtility(AudioUtilityRequest request)
{
TestHelper
.GetAudioUtilityFfmpegRawPcm()
.Modify(
this.source,
MediaTypes.GetMediaType(this.source.Extension),
this.output,
MediaTypes.GetMediaType(this.output.Extension),
request);
}
public void AdvancedChannelSelectionFfmpegRawPcmFails(int[] channelMap)
{
var audioUtilityRequest = new AudioUtilityRequest
{
Channels = channelMap,
MixDownToMono = false,
TargetSampleRate = 22050,
BitDepth = 16,
};
var mediaType = MediaTypes.MediaTypePcmRaw;
var otherMediaType = MediaTypes.MediaTypeWav1;
var utility = TestHelper.GetAudioUtilityFfmpegRawPcm();
var file = FourChannelFileRaw;
Assert.ThrowsException <ChannelSelectionOperationNotImplemented>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
audioUtilityRequest.MixDownToMono = true;
Assert.ThrowsException <ChannelSelectionOperationNotImplemented>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
audioUtilityRequest.Channels = null;
Assert.ThrowsException <InvalidOperationException>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
}
private static void AssertAdvancedChannelConversionFails(string file, string mediaType, IAudioUtility utility, string otherMediaType = null, bool skipMonoCheck = false)
{
// array of channels of frequencies (expected in each channel)
var audioUtilityRequest = new AudioUtilityRequest {
Channels = new[] { 1, 2, 3, 4 }, MixDownToMono = false
};
otherMediaType = otherMediaType ?? mediaType;
Assert.ThrowsException <ChannelSelectionOperationNotImplemented>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
audioUtilityRequest.MixDownToMono = true;
Assert.ThrowsException <ChannelSelectionOperationNotImplemented>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
if (skipMonoCheck)
{
return;
}
audioUtilityRequest.Channels = null;
Assert.ThrowsException <ChannelSelectionOperationNotImplemented>(
() =>
{
utility.Modify(
TestHelper.GetAudioFile(file),
mediaType,
TempFileHelper.NewTempFile(MediaTypes.GetExtension(otherMediaType)),
otherMediaType,
audioUtilityRequest);
});
}
public void FfmpegRawPcmFailsSelectsAllChannelsCorrectly()
{
// array of channels of frequencies (expected in each channel)
// expect 4 channels
var expectedFrequencies = new[] { 4000.AsArray(), 3000.AsArray(), 2000.AsArray(), 1000.AsArray() };
// raw conversions need extra information to work
var request = new AudioUtilityRequest()
{
BitDepth = 16, TargetSampleRate = 44100
};
ChannelTest(FourChannelFileRaw, new[] { 1, 2, 3, 4 }, null, expectedFrequencies, request);
}
public void FailsWithBandpassSet()
{
var request = new AudioUtilityRequest
{
BitDepth = 16,
TargetSampleRate = 22050,
Channels = new[] { 1, 2, 3, 4 },
BandPassType = BandPassType.Bandpass,
};
TestHelper.ExceptionMatches <NotSupportedException>(
() => { this.RunUtility(request); },
"Bandpass operations are not supported");
}
private FileInfo SegmentWavpackToWav(FileInfo source, AudioUtilityRequest request)
{
// use a temp file for wvunpack.
var wavunpackTempFile = TempFileHelper.NewTempFile(this.TemporaryFilesDirectory, MediaTypes.GetExtension(MediaTypes.MediaTypeWav));
if (this.Log.IsDebugEnabled)
{
this.Log.Debug("Segmenting wavpack file " + source.FullName + " to wav " + wavunpackTempFile.FullName + " using wvunpack. Settings: " + request);
}
// use wvunpack to segment and convert to wav.
this.wvunpackUtility.Modify(source, MediaTypes.MediaTypeWavpack, wavunpackTempFile, MediaTypes.MediaTypeWav, request);
return(wavunpackTempFile);
}
public void FailsChannelSelection()
{
var request = new AudioUtilityRequest
{
BitDepth = 16,
TargetSampleRate = 22050,
Channels = new[] { 5, 2, 3, 4 },
//BandPass
};
TestHelper.ExceptionMatches <ChannelSelectionOperationNotImplemented>(
() => { this.RunUtility(request); },
"The Channels specifier must contain channel numbers");
}
public void FailsWithMissingChannels()
{
var request = new AudioUtilityRequest
{
BitDepth = 16,
TargetSampleRate = 22050,
//Channels = new[] { 1, 2, 3, 4 },
//BandPass
};
TestHelper.ExceptionMatches <InvalidOperationException>(
() => { this.RunUtility(request); },
"The Channels must be set");
}
private static void SegmentsCorrectly(
string filename, string mimetype, TimeSpan start, TimeSpan end, TimeSpan maxVariance)
{
foreach (var util in new[] { TestHelper.GetAudioUtility() })
{
var dir = PathHelper.GetTempDir();
var destMimeType = mimetype;
if (mimetype == MediaTypes.MediaTypeWavpack)
{
destMimeType = MediaTypes.MediaTypeWav;
}
var output =
new FileInfo(
Path.Combine(
dir.FullName,
Path.GetFileNameWithoutExtension(filename) + "_segmented."
+ MediaTypes.GetExtension(destMimeType)));
var audioUtilRequest = new AudioUtilityRequest {
OffsetStart = start, OffsetEnd = end
};
var input = PathHelper.GetTestAudioFile(filename);
util.Modify(input, mimetype, output, destMimeType, audioUtilRequest);
var utilInfoInput = util.Info(input);
var utilInfoOutput = util.Info(output);
var infoInput = GetDurationInfo(utilInfoInput);
var infoOutput = GetDurationInfo(utilInfoOutput);
var compareResult = "Expected duration " + (end - start) + " actual duration " + utilInfoOutput.Duration.Value
+ " expected max variation " + maxVariance + " actual variation "
+ (end - start).Subtract(utilInfoOutput.Duration.Value).Duration();
using (var cr = new ConsoleRedirector())
{
LoggedConsole.WriteLine(compareResult);
}
Assert.IsTrue(
TestHelper.CompareTimeSpans(utilInfoOutput.Duration.Value, end - start, maxVariance),
compareResult + ". Info input: " + infoInput + "." + Environment.NewLine + "Info output: " + infoOutput);
PathHelper.DeleteTempDir(dir);
}
}
protected override void CheckRequestValid(
FileInfo source,
string sourceMediaType,
FileInfo output,
string outputMediaType,
AudioUtilityRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), " must not be null - raw PCM data requires prior knowledge");
}
if (request.BitDepth == null)
{
throw new InvalidOperationException($"A {nameof(request.BitDepth)} must be supplied - can not be null");
}
if (!this.ValidBitDepths.Contains(request.BitDepth.Value))
{
throw new BitDepthOperationNotImplemented($"Supplied bit depth of {request.BitDepth.Value} is not valid");
}
if (request.BandPassType != BandPassType.None ||
request.BandpassHigh.NotNull() ||
request.BandpassLow.NotNull())
{
throw new NotSupportedException("Bandpass operations are not supported");
}
if (request.TargetSampleRate == null)
{
var message = $"A {nameof(request.TargetSampleRate)} must be supplied to the {nameof(FfmpegRawPcmAudioUtility)}";
throw new InvalidOperationException(message);
}
if (request.Channels.IsNullOrEmpty())
{
var message = $"The {nameof(request.Channels)} must be set for the {nameof(FfmpegRawPcmAudioUtility)}";
throw new InvalidOperationException(message);
}
if (request.Channels.Select((c, i) => c == i + 1).Any(b => !b))
{
var message =
$"The {nameof(request.Channels)} specifier must contain channel numbers mapping to their index only for the {nameof(FfmpegRawPcmAudioUtility)}";
throw new ChannelSelectionOperationNotImplemented(message);
}
}
internal static void FormatFfmpegOffsetArgs(AudioUtilityRequest request, StringBuilder args)
{
if (request.OffsetStart.HasValue && request.OffsetStart.Value > TimeSpan.Zero)
{
args.AppendFormat(ArgsSeek, FormatTimeSpan(request.OffsetStart.Value));
}
if (request.OffsetEnd.HasValue && request.OffsetEnd.Value > TimeSpan.Zero)
{
var duration = request.OffsetStart.HasValue
? FormatTimeSpan(request.OffsetEnd.Value - request.OffsetStart.Value)
: FormatTimeSpan(request.OffsetEnd.Value - TimeSpan.Zero);
args.AppendFormat(ArgsDuration, duration);
}
}
private FileInfo SegmentRawPcmToWav(FileInfo source, AudioUtilityRequest request)
{
// use a temp file for wvunpack.
var extension = MediaTypes.GetExtension(MediaTypes.MediaTypeWav1);
var rawFile = TempFileHelper.NewTempFile(this.TemporaryFilesDirectory, extension);
if (this.Log.IsDebugEnabled)
{
this.Log.Debug("Converting/segmenting raw file " + source.FullName + " to wav " + rawFile.FullName + " using ffmpeg. Settings: " + request);
}
// use ffmpeg to segment and convert to wav.
this.ffmpegRawPcmUtility.Modify(source, MediaTypes.MediaTypePcmRaw, rawFile, MediaTypes.MediaTypeWav, request);
return(rawFile);
}
private FileInfo ConvertNonWavOrMp3(FileInfo source, string sourceMimeType, AudioUtilityRequest request)
{
// use a temp file to segment.
var ffmpegTempFile = TempFileHelper.NewTempFile(this.TemporaryFilesDirectory, MediaTypes.GetExtension(MediaTypes.MediaTypeWav));
if (this.Log.IsDebugEnabled)
{
this.Log.Debug("Converting " + sourceMimeType + " file " + source.FullName + " to wav " +
ffmpegTempFile.FullName + " using ffmpeg. Settings: " + request);
}
// use ffmpeg to segment.
this.ffmpegUtility.Modify(source, sourceMimeType, ffmpegTempFile, MediaTypes.MediaTypeWav, request);
return(ffmpegTempFile);
}
public void FfmpegRawPcmFailsMixesDown1234Correctly()
{
// array of channels of frequencies (expected in each channel)
var expectedFrequencies = new[]
{
new[] { 4000 },
new[] { 3000 },
new[] { 2000 },
new[] { 1000 },
};
// raw conversions need extra information to work
var request = new AudioUtilityRequest()
{
BitDepth = 16, TargetSampleRate = 44100
};
ChannelTest(FourChannelFileRaw, new[] { 1, 2, 3, 4 }, false, expectedFrequencies, request);
}
