コード例 #1
0
        static void ValidateSettings(SettingsDictionary settings, ISampleEncoder encoder)
        {
            Contract.Requires(settings != null);
            Contract.Requires(encoder != null);

            foreach (string unsupportedKey in settings.Keys.Where(setting =>
                                                                  !encoder.EncoderInfo.AvailableSettings.Contains(setting, StringComparer.OrdinalIgnoreCase)))
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                                                          Resources.ExportableAudioFileSettingsError, unsupportedKey));
            }
        }
コード例 #2
0
        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);
            }
        }
コード例 #3
0
        static FileInfo GetOutputFileInfo(FileInfo inputFileInfo, DirectoryInfo outputDirectory, string outputFileName, ISampleEncoder sampleEncoder)
        {
            Contract.Requires(inputFileInfo != null);
            Contract.Requires(sampleEncoder != null);
            Contract.Ensures(Contract.Result <FileInfo>() != null);

            // Use the input file name if the output name wasn't specified:
            if (string.IsNullOrEmpty(outputFileName))
            {
                outputFileName = Path.GetFileNameWithoutExtension(inputFileInfo.Name);
            }

            // Use the input file's directory if the output directory wasn't specified:
            if (outputDirectory == null)
            {
                outputDirectory = new DirectoryInfo(inputFileInfo.DirectoryName ?? string.Empty);
            }
            else
            {
                outputDirectory.Create();
            }

            return(new FileInfo(Path.Combine(outputDirectory.FullName, outputFileName + sampleEncoder.EncoderInfo.FileExtension)));
        }