public void TC03_VBRPreset()
        {
            // Presets to test, should result in different sizes for all cases
            var presets = new[] { LAMEPreset.STANDARD, LAMEPreset.EXTREME, LAMEPreset.ABR_160, LAMEPreset.V1, LAMEPreset.V4, LAMEPreset.V6, LAMEPreset.V9 };
            var results = new Dictionary <LAMEPreset, long>();

            foreach (var preset in presets)
            {
                var config = new LameConfig {
                    Preset = preset
                };
                if (preset == LAMEPreset.STANDARD)
                {
                    config.BitRate = 128;
                }

                using (var mp3data = EncodeSampleFile(config))
                {
                    results[preset] = mp3data.Length;
                }
            }

            // Compare encoded sizes for all combinations of presets
            for (int i = 0; i < presets.Length - 2; i++)
            {
                var left = results[presets[i]];
                for (int j = i + 1; j < presets.Length; j++)
                {
                    var right = results[presets[j]];

                    Assert.AreNotEqual(left, right, $"{presets[i]} size matched {presets[j]}");
                }
            }
        }
        private static Stream EncodeSilence(LameConfig config, WaveFormat format, int seconds = 1)
        {
            var mp3data = new MemoryStream();

            using (var mp3writer = new LameMP3FileWriter(mp3data, format, config))
            {
                var bfr = new byte[format.AverageBytesPerSecond * seconds];
                mp3writer.Write(bfr, 0, bfr.Length);
            }

            mp3data.Position = 0;
            return(mp3data);
        }
Example #3
0
            public MP3(string inputPath, string outputPath, Bitrates bitrate = Bitrates._320, MPEGMode mPEGMode = MPEGMode.JointStereo, IProgress <EncodeProgress> progress = null)
            {
                this.Bitrate          = bitrate;
                this.InputPath        = inputPath;
                this.OutputPath       = outputPath;
                this.InternalProgress = progress;

                LConfig = new LameConfig()
                {
                    BitRate  = Convert.ToInt32(this.Bitrate.GetEnumDescription()),
                    Analysis = true,
                    Mode     = mPEGMode
                };
            }
Example #4
0
        public void TC03_VBRPreset()
        {
            // Presets to test, should result in different sizes for all cases
            var presets = new[] { LAMEPreset.STANDARD, LAMEPreset.EXTREME, LAMEPreset.ABR_160, LAMEPreset.V1, LAMEPreset.V4, LAMEPreset.V6, LAMEPreset.V9 };
            var results = new Dictionary <LAMEPreset, long>();

            WaveFormat sourceFormat;

            using (var srcms = new MemoryStream())
            {
                using (var source = new AudioFileReader(SourceFilename))
                {
                    sourceFormat = source.WaveFormat;
                    source.CopyTo(srcms);
                }

                foreach (var preset in presets)
                {
                    var config = new LameConfig {
                        Preset = preset
                    };
                    if (preset == LAMEPreset.STANDARD)
                    {
                        config.BitRate = 128;
                    }

                    using (var mp3data = new MemoryStream())
                    {
                        using (var mp3writer = new LameMP3FileWriter(mp3data, sourceFormat, preset))
                        {
                            srcms.Position = 0;
                            srcms.CopyTo(mp3writer);
                        }
                        results[preset] = mp3data.Length;
                    }
                }
            }
            // Compare encoded sizes for all combinations of presets
            for (int i = 0; i < presets.Length - 2; i++)
            {
                var left = results[presets[i]];
                for (int j = i + 1; j < presets.Length; j++)
                {
                    var right = results[presets[j]];

                    Assert.AreNotEqual(left, right, $"{presets[i]} size matched {presets[j]}");
                }
            }
        }
        private static Stream EncodeSampleFile(LameConfig config, int copies = 1)
        {
            var mp3data = new MemoryStream();

            using (var source = new AudioFileReader(SourceFilename))
                using (var mp3writer = new LameMP3FileWriter(mp3data, source.WaveFormat, config))
                {
                    for (int i = 0; i < copies; i++)
                    {
                        source.Position = 0;
                        source.CopyTo(mp3writer);
                    }
                }

            mp3data.Position = 0;
            return(mp3data);
        }
Example #6
0
        private static void ConvertBytesToMp3_Windows(byte[] wavBytes, string destinationFilePath)
        {
            // Larry Hayashi's recommended lame settings
            // "lame.exe" -V 8 -b 16 -F -B -a -m m -q 1
            // -a (downmix) not supported by NAudio.Lame yet
            // -b 16 (minimum bitrate) not supported by NAudio.Lame yet
            // -q 1 (algorithm quality) not supported by NAudio.Lame yet
            // -B (maximum bitrate) not supported by NAudio.Lame and should have an arg
            // -F (strictly enforce minimum bitrate) not supported by NAudio.Lame
            var lameConfig = new LameConfig
            {
                Preset = LAMEPreset.V8,               // -V 8
                Mode   = MPEGMode.Mono,               // -m m
                //MinimumBitRate = 16,
                //MaximumBitRate = 128,
                //ForceMinimum = true,
                //VBRAlgorithmQuality = 1
            };

            try
            {
                using (var outputStream = new MemoryStream())
                    using (var inputStream = new MemoryStream(wavBytes))
                        using (var fileReader = new WaveFileReader(inputStream))
                            using (var fileWriter = new LameMP3FileWriter(outputStream, fileReader.WaveFormat, lameConfig))
                            {
                                fileWriter.OnProgress += (writer, bytes, outputBytes, finished) =>
                                {
                                    if (finished)
                                    {
                                        var mp3Bytes = outputStream.ToArray();
                                        SaveBytes(destinationFilePath, mp3Bytes);
                                    }
                                };
                                fileReader.CopyTo(fileWriter);
                                fileWriter.Flush();
                            }
            }
            catch (ArgumentException e)
            {
                MessageBoxUtils.Show(null, string.Format(FwUtilsStrings.ConvertBytesToMp3_BadWavFile,
                                                         Path.GetFileName(destinationFilePath),
                                                         Environment.NewLine,
                                                         e.Message), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }