/// <param name="type">The UIViewType</param>
/// <param name="v">The IView</param>
/// <param name="vm">The IViewModel. Might be null because the 2fa view shares the same viewmodel as the login dialog, so it's
/// set manually in the view outside of this</param>
public UIPair(UIViewType type, ExportLifetimeContext<IView> v, [AllowNull]ExportLifetimeContext<IViewModel> vm)
{
viewType = type;
view = v;
viewModel = vm;
handlers = new CompositeDisposable();
}
void LoadAudioInfo()
{
Contract.Ensures(AudioInfo != null);
using (FileStream fileStream = FileInfo.OpenRead())
{
// Try each info decoder that supports this file extension:
foreach (ExportFactory <IAudioInfoDecoder> decoderFactory in
ExtensionProvider.GetFactories <IAudioInfoDecoder>("Extension", FileInfo.Extension))
{
try
{
using (ExportLifetimeContext <IAudioInfoDecoder> lifetimeContext = decoderFactory.CreateExport())
AudioInfo = lifetimeContext.Value.ReadAudioInfo(fileStream);
return;
}
catch (UnsupportedAudioException)
{
// If a decoder wasn't supported, rewind the stream and try another:
fileStream.Position = 0;
}
}
}
throw new UnsupportedAudioException(Resources.AudioFileDecodeError);
}
public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
_encoder = new NativeVorbisEncoder();
_output = stream;
// Load the external gain filter:
ExportFactory <ISampleFilter> sampleFilterFactory =
ExtensionProvider.GetFactories <ISampleFilter>("Name", "ReplayGain").SingleOrDefault();
if (sampleFilterFactory == null)
{
throw new ExtensionInitializationException(Resources.SampleEncoderReplayGainFilterError);
}
_replayGainFilterLifetime = sampleFilterFactory.CreateExport();
_replayGainFilterLifetime.Value.Initialize(metadata, settings);
_oggStream = IntializeOggStream(settings);
_buffer = new byte[4096];
if (!string.IsNullOrEmpty(settings["BitRate"]))
{
ConfigureEncoderForBitRate(settings, audioInfo, _encoder);
}
else
{
ConfigureEncoderForQuality(settings, audioInfo, _encoder);
}
WriteHeader(metadata, stream);
}
/// <param name="type">The UIViewType</param>
/// <param name="v">The IView</param>
/// <param name="vm">The IViewModel. Might be null because the 2fa view shares the same viewmodel as the login dialog, so it's
/// set manually in the view outside of this</param>
public UIPair(UIViewType type, ExportLifetimeContext <IView> v, [AllowNull] ExportLifetimeContext <IViewModel> vm)
{
viewType = type;
view = v;
viewModel = vm;
handlers = new CompositeDisposable();
}
/// <summary>
/// Saves the metadata, using an available <see cref="IMetadataEncoder"/>. If no extensions are able to write
/// to this file extension, an <see cref="UnsupportedAudioException"/>
/// </summary>
/// <param name="settings">The settings.</param>
/// <exception cref="UnsupportedAudioException">
/// No metadata encoders are able to save metadata in the required format.
/// </exception>
public void SaveMetadata(SettingsDictionary settings = null)
{
if (settings == null)
{
settings = new SettingsDictionary();
}
using (FileStream fileStream = FileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
// Ensure the existing metadata has been loaded:
if (_metadata == null)
{
LoadMetadata(fileStream);
fileStream.Position = 0;
}
// Try each encoder that supports the file extension:
foreach (ExportFactory <IMetadataEncoder> encoderFactory in
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", FileInfo.Extension))
{
using (ExportLifetimeContext <IMetadataEncoder> lifetimeContext = encoderFactory.CreateExport())
{
IMetadataEncoder encoder = lifetimeContext.Value;
ValidateSettings(settings, encoder);
encoder.WriteMetadata(fileStream, Metadata, settings);
return;
}
}
}
throw new UnsupportedAudioException(Resources.TaggedAudioFileUnsupportedError);
}
void LoadMetadata(Stream stream)
{
Contract.Requires(stream != null);
Contract.Requires(stream.CanRead);
Contract.Requires(stream.CanSeek);
Contract.Ensures(_metadata != null);
// Try each decoder that supports this file extension:
foreach (ExportFactory <IMetadataDecoder> decoderFactory in
ExtensionProvider.GetFactories <IMetadataDecoder>("Extension", FileInfo.Extension))
{
try
{
using (ExportLifetimeContext <IMetadataDecoder> lifetimeContext = decoderFactory.CreateExport())
_metadata = lifetimeContext.Value.ReadMetadata(stream);
return;
}
catch (UnsupportedAudioException)
{
// If a decoder wasn't supported, rewind the stream and try another:
stream.Position = 0;
}
}
_metadata = new MetadataDictionary();
}
public IObservable <LoadData> SetupUI(UIControllerFlow controllerFlow, [AllowNull] IConnection connection)
{
StopUI();
var factory = TryGetService(typeof(IExportFactoryProvider)) as IExportFactoryProvider;
currentUIFlow = factory.UIControllerFactory.CreateExport();
var disposable = currentUIFlow;
var ui = currentUIFlow.Value;
var creation = ui.SelectFlow(controllerFlow);
windowController = new UI.WindowController(creation);
windowController.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
windowController.Closed += StopUIFlowWhenWindowIsClosedByUser;
creation.Subscribe(c => {}, () =>
{
windowController.Closed -= StopUIFlowWhenWindowIsClosedByUser;
windowController.Close();
if (currentUIFlow != disposable)
{
StopUI(disposable);
}
else
{
StopUI();
}
});
ui.Start(connection);
return(creation);
}
protected override async Task InitializeCoreAsync(CancellationToken cancellationToken)
{
_contextAccessor = await _workspaceProjectContextProvider.CreateProjectContextAsync(_project);
if (_contextAccessor == null)
{
return;
}
_activeWorkspaceProjectContextTracker.RegisterContext(_contextAccessor.ContextId);
_disposables = new DisposableBag(CancellationToken.None);
_applyChangesToWorkspaceContext = _applyChangesToWorkspaceContextFactory.CreateExport();
_applyChangesToWorkspaceContext.Value.Initialize(_contextAccessor.Context);
_disposables.AddDisposable(_applyChangesToWorkspaceContext);
_evaluationProgressRegistration = _dataProgressTrackerService.RegisterForIntelliSense(_project, nameof(WorkspaceProjectContextHostInstance) + ".Evaluation");
_disposables.AddDisposable(_evaluationProgressRegistration);
_projectBuildProgressRegistration = _dataProgressTrackerService.RegisterForIntelliSense(_project, nameof(WorkspaceProjectContextHostInstance) + ".ProjectBuild");
_disposables.AddDisposable(_projectBuildProgressRegistration);
// We avoid suppressing version updates, so that progress tracker doesn't
// think we're still "in progress" in the case of an empty change
_disposables.AddDisposable(_projectSubscriptionService.ProjectRuleSource.SourceBlock.LinkToAsyncAction(
target: e => OnProjectChangedAsync(e, evaluation: true),
suppressVersionOnlyUpdates: false,
ruleNames: _applyChangesToWorkspaceContext.Value.GetProjectEvaluationRules()));
_disposables.AddDisposable(_projectSubscriptionService.ProjectBuildRuleSource.SourceBlock.LinkToAsyncAction(
target: e => OnProjectChangedAsync(e, evaluation: false),
suppressVersionOnlyUpdates: false,
ruleNames: _applyChangesToWorkspaceContext.Value.GetProjectBuildRules()));
}
public void Analyze(string analyzer, CancellationToken cancelToken, GroupToken groupToken = null)
{
Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(analyzer));
var groupTokenOwned = false;
try
{
if (groupToken == null)
{
groupToken = new GroupToken(1);
groupTokenOwned = true;
}
ExportFactory <ISampleAnalyzer> analyzerFactory =
ExtensionProvider.GetFactories <ISampleAnalyzer>("Name", analyzer).SingleOrDefault();
if (analyzerFactory == null)
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Resources.AnalyzableAudioFileFactoryError, analyzer),
nameof(analyzer));
}
using (ExportLifetimeContext <ISampleAnalyzer> analyzerLifetime = analyzerFactory.CreateExport())
DoAnalyze(analyzerLifetime.Value, cancelToken, groupToken);
}
finally
{
if (groupTokenOwned)
{
groupToken.Dispose();
}
}
}
public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
Contract.Ensures(_encoder != null);
// Load the external gain filter:
ExportFactory <ISampleFilter> sampleFilterFactory =
ExtensionProvider.GetFactories <ISampleFilter>("Name", "ReplayGain").SingleOrDefault();
if (sampleFilterFactory == null)
{
throw new ExtensionInitializationException(Resources.SampleEncoderReplayGainFilterError);
}
_replayGainFilterLifetime = sampleFilterFactory.CreateExport();
_replayGainFilterLifetime.Value.Initialize(metadata, settings);
// Call the external ID3 encoder:
ExportFactory <IMetadataEncoder> metadataEncoderFactory =
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", EncoderInfo.FileExtension).Single();
if (metadataEncoderFactory == null)
{
throw new ExtensionInitializationException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderMetadataEncoderError, EncoderInfo.FileExtension));
}
using (ExportLifetimeContext <IMetadataEncoder> metadataEncoderLifetime = metadataEncoderFactory.CreateExport())
metadataEncoderLifetime.Value.WriteMetadata(stream, metadata, settings);
_encoder = InitializeEncoder(audioInfo, stream);
ConfigureEncoder(settings, _encoder);
if (_encoder.InitializeParams() != 0)
{
throw new IOException(Resources.SampleEncoderFailedToInitialize);
}
}
private ILifetime <TPresenter, IPresenterMetadata> CreatePresenter <TPresenter>(string id) where TPresenter : IPresenter
{
ExportFactory <IPresenter, IPresenterMetadata> factory = FindPresenterFactory(id);
ExportLifetimeContext <IPresenter> presenter = factory.CreateExport();
return(new PresenterLifetime <TPresenter>(presenter, factory.Metadata));
}
protected void SetupViewModel <VM>(IExportFactoryProvider factory, GitHub.Exports.UIViewType type)
where VM : class, IViewModel
{
var v = Substitute.For <VM, INotifyPropertyChanged>();
var e = new ExportLifetimeContext <IViewModel>(v, () => { });
factory.GetViewModel(type).Returns(e);
}
/// <param name="type">The UIViewType</param>
/// <param name="v">The IView</param>
/// <param name="vm">The IViewModel. Might be null because the 2fa view shares the same viewmodel as the login dialog, so it's
/// set manually in the view outside of this</param>
public UIPair(UIViewType type, ExportLifetimeContext <IView> v, ExportLifetimeContext <IViewModel> vm)
{
Guard.ArgumentNotNull(v, nameof(v));
viewType = type;
view = v;
viewModel = vm;
handlers = new CompositeDisposable();
}
protected override async Task InitializeCoreAsync(CancellationToken cancellationToken)
{
_contextAccessor = await _workspaceProjectContextProvider.CreateProjectContextAsync(_project);
if (_contextAccessor == null)
{
return;
}
_activeWorkspaceProjectContextTracker.RegisterContext(_contextAccessor.ContextId);
_applyChangesToWorkspaceContext = _applyChangesToWorkspaceContextFactory.CreateExport();
_applyChangesToWorkspaceContext.Value.Initialize(_contextAccessor.Context);
_evaluationProgressRegistration = _dataProgressTrackerService.RegisterForIntelliSense(this, _project, nameof(WorkspaceProjectContextHostInstance) + ".Evaluation");
_projectBuildProgressRegistration = _dataProgressTrackerService.RegisterForIntelliSense(this, _project, nameof(WorkspaceProjectContextHostInstance) + ".ProjectBuild");
_sourceItemsProgressRegistration = _dataProgressTrackerService.RegisterForIntelliSense(this, _project, nameof(WorkspaceProjectContextHostInstance) + ".SourceItems");
_disposables = new DisposableBag
{
_applyChangesToWorkspaceContext,
_evaluationProgressRegistration,
_projectBuildProgressRegistration,
_sourceItemsProgressRegistration,
ProjectDataSources.SyncLinkTo(
_activeConfiguredProjectProvider.ActiveConfiguredProjectBlock.SyncLinkOptions(),
_projectSubscriptionService.ProjectRuleSource.SourceBlock.SyncLinkOptions(GetProjectEvaluationOptions()),
target: DataflowBlockFactory.CreateActionBlock <IProjectVersionedValue <ValueTuple <ConfiguredProject, IProjectSubscriptionUpdate> > >(e =>
OnProjectChangedAsync(new ProjectChange(e), WorkspaceContextHandlerType.Evaluation),
_project.UnconfiguredProject,
ProjectFaultSeverity.LimitedFunctionality),
linkOptions: DataflowOption.PropagateCompletion,
cancellationToken: cancellationToken),
ProjectDataSources.SyncLinkTo(
_activeConfiguredProjectProvider.ActiveConfiguredProjectBlock.SyncLinkOptions(),
_projectSubscriptionService.ProjectBuildRuleSource.SourceBlock.SyncLinkOptions(GetProjectBuildOptions()),
_projectBuildSnapshotService.SourceBlock.SyncLinkOptions(),
target: DataflowBlockFactory.CreateActionBlock <IProjectVersionedValue <ValueTuple <ConfiguredProject, IProjectSubscriptionUpdate, IProjectBuildSnapshot> > >(e =>
OnProjectChangedAsync(new ProjectChange(e), WorkspaceContextHandlerType.ProjectBuild),
_project.UnconfiguredProject,
ProjectFaultSeverity.LimitedFunctionality),
linkOptions: DataflowOption.PropagateCompletion,
cancellationToken: cancellationToken),
ProjectDataSources.SyncLinkTo(
_activeConfiguredProjectProvider.ActiveConfiguredProjectBlock.SyncLinkOptions(),
_projectSubscriptionService.SourceItemsRuleSource.SourceBlock.SyncLinkOptions(),
target: DataflowBlockFactory.CreateActionBlock <IProjectVersionedValue <ValueTuple <ConfiguredProject, IProjectSubscriptionUpdate> > >(e =>
OnProjectChangedAsync(new ProjectChange(e), WorkspaceContextHandlerType.SourceItems),
_project.UnconfiguredProject,
ProjectFaultSeverity.LimitedFunctionality),
linkOptions: DataflowOption.PropagateCompletion,
cancellationToken: cancellationToken),
};
}
protected override void ProcessRecord()
{
foreach (ExportFactory <ISampleEncoder> encoderFactory in string.IsNullOrEmpty(Name)
? ExtensionProvider.GetFactories <ISampleEncoder>()
: ExtensionProvider.GetFactories <ISampleEncoder>("Name", Name))
{
using (ExportLifetimeContext <ISampleEncoder> encoderLifetime = encoderFactory.CreateExport())
WriteObject(encoderLifetime.Value.EncoderInfo);
}
}
protected override void ProcessRecord()
{
foreach (ExportFactory <IMetadataEncoder> factory in string.IsNullOrEmpty(Extension)
? ExtensionProvider.GetFactories <IMetadataEncoder>()
: ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", Extension))
{
using (ExportLifetimeContext <IMetadataEncoder> encoderLifetime = factory.CreateExport())
WriteObject(encoderLifetime.Value.EncoderInfo);
}
}
/// <summary>
/// Закрыть главное окно
/// </summary>
private void CloseMainViewModel()
{
if (_mainViewModel != null)
{
_mainViewModel.Dispose();
_mainViewModel.Close();
_mainViewModelExport.Dispose();
_mainViewModel = null;
_mainViewModelExport = null;
}
}
public void StopUI()
{
if (!Initialized)
{
log.Error("ExportProvider is not initialized, cannot stop UI.");
return;
}
StopUI(currentUIFlow);
currentUIFlow = null;
}
/// <summary>
/// Закрыть главное окно
/// </summary>
private void CloseMainViewModel()
{
if (_mainViewModel != null)
{
_mainViewModel.Dispose();
_mainViewModel.Close();
_mainViewModelExport.Dispose();
_mainViewModel = null;
_mainViewModelExport = null;
}
}
protected void SetupView <VM>(IExportFactoryProvider factory, GitHub.Exports.UIViewType type)
where VM : class, IViewModel
{
var view = Substitute.For <IView, IViewFor <VM> >();
var viewModel = factory.GetViewModel(type).Value;
view.ViewModel.Returns(viewModel);
var e = new ExportLifetimeContext <IView>(view, () => { });
factory.GetView(type).Returns(e);
}
void GameChanged(Game x)
{
var previousContext = _activeGameContext;
_activeGameContext = Factory.CreateGame(x);
ActiveGame = x == null ? null : _activeGameContext.Value;
if (previousContext != null)
{
previousContext.Dispose();
}
}
protected void SetupViewModel <VM>(IExportFactoryProvider factory, GitHub.Exports.UIViewType type)
where VM : class, IViewModel
{
var v = Substitute.For <IDialogViewModel, VM, INotifyPropertyChanged>();
var done = new ReplaySubject <Unit>();
var cancel = ReactiveCommand.Create();
v.Done.Returns(_ => done);
v.Cancel.Returns(cancel);
((IHasCancel)v).Cancel.Returns(cancel.SelectUnit());
var e = new ExportLifetimeContext <IViewModel>(v, () => { });
factory.GetViewModel(type).Returns(e);
}
void Run()
{
var catalog = new DirectoryCatalog(".");
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
ExportLifetimeContext <ICarContract> carA = carFactory.CreateExport();
ExportLifetimeContext <ICarContract> carB = carFactory.CreateExport();
carA.Value.DoSomething("carA");
carB.Value.DoSomething("carB");
carA.Dispose();
carB.Dispose();
}
static void StopUI(ExportLifetimeContext <IUIController> disposable)
{
try {
if (disposable != null && disposable.Value != null)
{
if (!disposable.Value.IsStopped)
{
disposable.Value.Stop();
}
disposable.Dispose();
}
}
catch (Exception ex)
{
log.Error("Failed to dispose UI. {0}", ex);
}
}
private Lifetime<ICommand> CreateCommand(string id, out bool cache)
{
ExportFactory<ICommand, ICommandMetadata> factory = _commands.Where(c => c.Metadata.Id == id)
.SingleOrDefault();
cache = false;
if (factory == null)
return null;
ExportLifetimeContext<ICommand> context = factory.CreateExport();
if (factory.Metadata.IsReusable)
{
cache = true;
return new Lifetime<ICommand>(() => context.Value, (Action)null);
}
// Don't catch non-reusable commands, they are created for every request to FindCommand
return new Lifetime<ICommand>(() => context.Value, () => context.Dispose());
}
protected void SetupView <VM>(IExportFactoryProvider factory, GitHub.Exports.UIViewType type)
where VM : class, IViewModel
{
IView view;
//if (type == GitHub.Exports.UIViewType.PRList)
// view = Substitutes.For<IView, IViewFor<VM>, IHasCreationView, IHasDetailView>();
//else
view = Substitute.For <IView, IViewFor <VM> >();
view.Done.Returns(new ReplaySubject <ViewWithData>());
view.Cancel.Returns(new ReplaySubject <ViewWithData>());
//(view as IHasDetailView)?.Open.Returns(new ReplaySubject<ViewWithData>());
//(view as IHasCreationView)?.Create.Returns(new ReplaySubject<ViewWithData>());
var e = new ExportLifetimeContext <IView>(view, () => { });
factory.GetView(type).Returns(e);
}
protected override async Task InitializeCoreAsync(CancellationToken cancellationToken)
{
_context = await _workspaceProjectContextProvider.CreateProjectContextAsync(_project);
if (_context == null)
{
return;
}
_applyChangesToWorkspaceContext = _applyChangesToWorkspaceContextFactory.CreateExport();
_applyChangesToWorkspaceContext.Value.Initialize(_context);
_subscriptions = new DisposableBag(CancellationToken.None);
_subscriptions.AddDisposable(_projectSubscriptionService.ProjectRuleSource.SourceBlock.LinkToAsyncAction(
target: e => OnProjectChangedAsync(e, evaluation: true),
ruleNames: _applyChangesToWorkspaceContext.Value.GetProjectEvaluationRules()));
_subscriptions.AddDisposable(_projectSubscriptionService.ProjectBuildRuleSource.SourceBlock.LinkToAsyncAction(
target: e => OnProjectChangedAsync(e, evaluation: false),
ruleNames: _applyChangesToWorkspaceContext.Value.GetProjectBuildRules()));
}
void Run()
{
// var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// var container = new CompositionContainer(catalog);
var managerCatalog = new TypeCatalog(typeof(CarManager));
var partCatalog = new TypeCatalog(typeof(CarHost), typeof(CarMercedes), typeof(CarBMW), typeof(CarGarage));
var scope = new CompositionScopeDefinition(
managerCatalog,
new[] { new CompositionScopeDefinition(partCatalog, null) });
var container = new CompositionContainer(scope);
var carManager = container.GetExportedValue <CarManager>();
ExportLifetimeContext <CarHost> carHostContextA = carManager.CreateCarHost();
Console.WriteLine("");
ExportLifetimeContext <CarHost> carHostContextB = carManager.CreateCarHost();
Console.WriteLine("");
foreach (ICarContract carParts in carHostContextA.Value.CarParts)
{
Console.WriteLine(carParts.DoSomething());
}
carHostContextA.Dispose();
Console.WriteLine("");
foreach (ICarContract carParts in carHostContextB.Value.CarParts)
{
Console.WriteLine(carParts.DoSomething());
}
carHostContextB.Dispose();
Console.WriteLine("");
Console.ReadLine();
}
public IObservable <LoadData> SetupUI(UIControllerFlow controllerFlow, [AllowNull] IConnection connection)
{
if (!Initialized)
{
log.Error("ExportProvider is not initialized, cannot setup UI.");
return(Observable.Empty <LoadData>());
}
StopUI();
var factory = GetService <IExportFactoryProvider>();
currentUIFlow = factory.UIControllerFactory.CreateExport();
var disposable = currentUIFlow;
var ui = currentUIFlow.Value;
var creation = ui.SelectFlow(controllerFlow);
windowController = new UI.WindowController(creation);
windowController.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
windowController.Closed += StopUIFlowWhenWindowIsClosedByUser;
creation.Subscribe(c => {}, () =>
{
windowController.Closed -= StopUIFlowWhenWindowIsClosedByUser;
windowController.Close();
if (currentUIFlow != disposable)
{
StopUI(disposable);
}
else
{
StopUI();
}
});
ui.Start(connection);
return(creation);
}
void DoAnalyze(ISampleAnalyzer sampleAnalyzer, CancellationToken cancelToken, GroupToken groupToken)
{
Contract.Requires(sampleAnalyzer != null);
Contract.Requires(groupToken != null);
sampleAnalyzer.Initialize(AudioInfo, groupToken);
using (FileStream fileStream = FileInfo.OpenRead())
{
// Try each decoder that supports this file extension:
foreach (ExportFactory <ISampleDecoder> decoderFactory in
ExtensionProvider.GetFactories <ISampleDecoder>("Extension", FileInfo.Extension))
{
try
{
using (ExportLifetimeContext <ISampleDecoder> decoderLifetime = decoderFactory.CreateExport())
{
ISampleDecoder sampleDecoder = decoderLifetime.Value;
sampleDecoder.Initialize(fileStream);
sampleDecoder.ReadWriteParallel(sampleAnalyzer, cancelToken,
sampleAnalyzer.ManuallyFreesSamples);
sampleAnalyzer.GetResult().CopyTo(Metadata);
return;
}
}
catch (UnsupportedAudioException)
{
// If a decoder wasn't supported, rewind the stream and try another:
fileStream.Position = 0;
}
}
}
throw new UnsupportedAudioException(Resources.AudioFileDecodeError);
}
void DoExport(ISampleEncoder encoder, Stream outputStream, SettingsDictionary settings, CancellationToken cancelToken)
{
Contract.Requires(encoder != null);
Contract.Requires(outputStream != null);
Contract.Requires(settings != null);
encoder.Initialize(outputStream, AudioInfo, Metadata, settings);
using (FileStream inputStream = FileInfo.OpenRead())
{
// Try each decoder that supports this file extension:
foreach (ExportFactory <ISampleDecoder> decoderFactory in
ExtensionProvider.GetFactories <ISampleDecoder>("Extension", FileInfo.Extension))
{
try
{
using (ExportLifetimeContext <ISampleDecoder> decoderLifetime = decoderFactory.CreateExport())
{
ISampleDecoder sampleDecoder = decoderLifetime.Value;
sampleDecoder.Initialize(inputStream);
sampleDecoder.ReadWriteParallel(encoder, cancelToken, encoder.ManuallyFreesSamples);
return;
}
}
catch (UnsupportedAudioException)
{
// If a decoder wasn't supported, rewind the stream and try another:
inputStream.Position = 0;
}
}
throw new UnsupportedAudioException(Resources.AudioFileDecodeError);
}
}
/// <summary>
/// Инициализировать главное окно
/// </summary>
private void InitializeMainViewModel()
{
_mainViewModelExport = _mainViewModelExportFactory.CreateExport();
_mainViewModel = _mainViewModelExport.Value;
_mainViewModel.Initialize();
}
async Task DownloadFilesAsync(StatusRepo sr,
IDictionary<KeyValuePair<string, Func<IAbsoluteFilePath, bool>>, ITransferStatus> transferStatuses,
IAbsoluteDirectoryPath destinationPath, ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector) {
destinationPath.MakeSurePathExists();
sr.Total = transferStatuses.Count;
using (var multiMirrorFileDownloader = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value))
using (var multi = _createQueueDownloader(multiMirrorFileDownloader.Value)) {
await multi.Value
.DownloadAsync(CreateFileQueueSpec(transferStatuses, destinationPath), sr.CancelToken)
.ConfigureAwait(false);
}
}
async Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath,
ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector, CancellationToken token,
Func<IAbsoluteFilePath, bool> confirmValidity, int zsyncHttpFallbackAfter) {
destinationPath.MakeSurePathExists();
using (var dl = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value)) {
await
dl.Value.DownloadAsync(new MultiMirrorFileDownloadSpec(remoteFile,
destinationPath.GetChildFileWithName(remoteFile), confirmValidity) {
CancellationToken = token,
Progress = new TransferStatus(remoteFile) {ZsyncHttpFallbackAfter = zsyncHttpFallbackAfter}
},
token).ConfigureAwait(false);
}
}
public void Submit(SampleCollection samples)
{
Contract.Ensures(_buffer != null);
if (_buffer == null)
{
_buffer = new int[samples.SampleCount * samples.Channels];
}
if (!samples.IsLast)
{
var index = 0;
for (var sample = 0; sample < samples.SampleCount; sample++)
{
for (var channel = 0; channel < samples.Channels; channel++)
{
_buffer[index++] = (int)Math.Round(samples[channel][sample] * _multiplier);
}
}
GCHandle handle = GCHandle.Alloc(_buffer, GCHandleType.Pinned);
try
{
var bufferList = new AudioBufferList
{
NumberBuffers = 1,
Buffers = new AudioBuffer[1]
};
bufferList.Buffers[0].NumberChannels = (uint)samples.Channels;
bufferList.Buffers[0].DataByteSize = (uint)(index * Marshal.SizeOf <int>());
bufferList.Buffers[0].Data = handle.AddrOfPinnedObject();
ExtendedAudioFileStatus status = _audioFile.Write(bufferList, (uint)samples.SampleCount);
if (status != ExtendedAudioFileStatus.Ok)
{
throw new IOException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderWriteError, status));
}
}
finally
{
handle.Free();
}
}
else
{
_audioFile.Dispose();
// Call an external MP4 encoder for writing iTunes-compatible atoms:
_stream.Position = 0;
ExportFactory <IMetadataEncoder> metadataEncoderFactory =
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", EncoderInfo.FileExtension)
.SingleOrDefault();
if (metadataEncoderFactory == null)
{
throw new ExtensionInitializationException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderMetadataEncoderError, EncoderInfo.FileExtension));
}
using (ExportLifetimeContext <IMetadataEncoder> metadataEncoderLifetime = metadataEncoderFactory.CreateExport())
metadataEncoderLifetime.Value.WriteMetadata(_stream, _metadata, _settings);
}
}
async Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath,
ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector, CancellationToken token) {
destinationPath.MakeSurePathExists();
using (var dl = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value)) {
await
dl.Value.DownloadAsync(new MultiMirrorFileDownloadSpec(remoteFile,
destinationPath.GetChildFileWithName(remoteFile)) {CancellationToken = token}, token)
.ConfigureAwait(false);
}
}
