Ejemplo n.º 1
0
        public override void Grab(CDDrive cd, Track track, string destFile, bool generateTags)
        {
            if (MustCancel())
                return;

            byte[] buff = base.GetTrackData(cd, track);

            if (MustCancel())
                return;

            ID3FileInfoSlim ifiSlim = new ID3FileInfoSlim(MediaFileInfo.Empty);
            ifiSlim.Album = track.Album;
            ifiSlim.Artist = track.Artist;
            ifiSlim.Genre = track.Genre;
            ifiSlim.Title = track.Title;
            ifiSlim.Track = (short)track.Index;

            short year = 1900;
            if (short.TryParse(track.Year, out year))
                ifiSlim.Year = year;

            EncodeBuffer(buff, destFile, generateTags, ifiSlim);
        }
Ejemplo n.º 2
0
        public void EncodeBuffer(byte[] buff, string destFile, bool generateTags, ID3FileInfoSlim ifiSlim)
        {
            uint LameResult = Lame_encDll.beInitStream(Mp3ConversionOptions, ref m_InputSamples, ref m_OutBufferSize, ref m_hLameStream);
            if (LameResult != Lame_encDll.BE_ERR_SUCCESSFUL)
            {
                throw new ApplicationException(string.Format("Lame_encDll.beInitStream failed with the error code {0}", LameResult));
            } 
            
            using (FileStream fs = new FileStream(destFile, FileMode.Create, FileAccess.Write, FileShare.None))
            using (BinaryWriter bw = new BinaryWriter(fs))
            {
                uint EncodedSize = 0;
                m_OutBuffer = new byte[m_OutBufferSize];

                if (MustCancel())
                    return;

                try
                {
                    int buffPos = 0;
                    while (buffPos < buff.Length)
                    {
                        if (MustCancel())
                            return;

                        m_OutBuffer = new byte[m_OutBufferSize];

                        uint bytesToCopy = Math.Min(2 * m_InputSamples, (uint)buff.Length - (uint)buffPos);

                        if ((LameResult = Lame_encDll.EncodeChunk(m_hLameStream, buff, buffPos, (uint)bytesToCopy, m_OutBuffer, ref EncodedSize)) == Lame_encDll.BE_ERR_SUCCESSFUL)
                        {
                            if (EncodedSize > 0)
                            {
                                bw.Write(m_OutBuffer, 0, (int)EncodedSize);
                            }
                        }
                        else
                        {
                            throw new ApplicationException(string.Format("Lame_encDll.EncodeChunk failed with the error code {0}", LameResult));
                        }

                        buffPos += (int)bytesToCopy;
                    }
                }
                finally
                {
                    EncodedSize = 0;
                    if (Lame_encDll.beDeinitStream(m_hLameStream, m_OutBuffer, ref EncodedSize) == Lame_encDll.BE_ERR_SUCCESSFUL)
                    {
                        if (EncodedSize > 0)
                        {
                            bw.Write(m_OutBuffer, 0, (int)EncodedSize);
                        }
                    }
                    Lame_encDll.beCloseStream(m_hLameStream);
                }
            }

            if (!MustCancel() && Mp3ConversionOptions.format.bWriteVBRHeader != 0)
            {
                uint err = Lame_encDll.beWriteVBRHeader(destFile);
            }

            if (!MustCancel() && generateTags && ifiSlim != null)
            {
                ID3FileInfo ifi = new ID3FileInfo(destFile, false);
                ifi.Album = StringUtils.Capitalize(ifiSlim.Album, WordCasing.CapitalizeWords);
                ifi.Artist = StringUtils.Capitalize(ifiSlim.Artist, WordCasing.CapitalizeWords);
                ifi.Genre = StringUtils.Capitalize(ifiSlim.Genre, WordCasing.CapitalizeWords);
                ifi.Title = StringUtils.Capitalize(ifiSlim.Title, WordCasing.CapitalizeWords);
                ifi.Track = ifiSlim.Track.GetValueOrDefault();
                ifi.Year = ifiSlim.Year.GetValueOrDefault();
                ifi.Save();
            }
        }
Ejemplo n.º 3
0
        public void DoTranscoding(EncoderSettingsContainer encoderSettings, string inputFile)
        {
            _grabber = CdRipper.CreateGrabber(OutputFormat);
            if (_grabber == null)
                throw new NotSupportedException(string.Format("TXT_UNSUPPORTED_OUTPUT_FORMAT: {0}", InputFormat));

            switch (InputFormat)
            {
                case AudioMediaFormatType.WAV:
                    switch (OutputFormat)
                    {
                        case AudioMediaFormatType.MP3:
                            {
                                // Transcode WAV => MP3 i.o.w encode the wav
                                WaveFormatEx wfex = WaveFormatEx.Cdda;
                                byte[] buff = ReadWAV(inputFile, ref wfex);
                                GrabberToMP3 grabber = (_grabber as GrabberToMP3);
                                grabber.Mp3ConversionOptions = encoderSettings.Mp3EncoderSettings.Mp3ConversionOptions;

                                // Resample is not supported at this time.
                                // Specify the same sample rate as the input WAV file, otherwise we'll be failing.
                                grabber.Mp3ConversionOptions.format.dwSampleRate = (uint)wfex.nSamplesPerSec;

                                grabber.EncodeBuffer(buff,
                                    Path.ChangeExtension(inputFile, "MP3"),
                                    false, null);
                                
                                return;
                            }
                    }
                    break;

                case AudioMediaFormatType.MP3:
                    switch (OutputFormat)
                    {
                        case AudioMediaFormatType.WAV:
                            // Transcode MP3 => WAV i.o.w decode the MP3
                            string outputFile = Path.ChangeExtension(inputFile, "WAV");
                            if (DecodeMP3ToWAV(inputFile, outputFile) == false)
                                throw new Exception("TXT_FAILED_CONVERSION_MP3_WAV");

                            return;

                        case AudioMediaFormatType.MP3:
                            {
                                // Transcode MP3 => MP3 i.o.w adjust MP3 encoding
                                string tempWavFile = Path.GetTempFileName();
                                if (DecodeMP3ToWAV(inputFile, tempWavFile) == false)
                                    throw new Exception("TXT_FAILED_CONVERSION_MP3_TEMP_WAV");

                                WaveFormatEx wfex = WaveFormatEx.Cdda;
                                byte[] buff = ReadWAV(tempWavFile, ref wfex);

                                GrabberToMP3 grabber = (_grabber as GrabberToMP3);
                                grabber.Mp3ConversionOptions = encoderSettings.Mp3EncoderSettings.Mp3ConversionOptions;

                                ID3FileInfoSlim ifiSlim = 
                                    new ID3FileInfoSlim(MediaFileInfo.FromPath(inputFile, false));

                                grabber.EncodeBuffer(buff,
                                    Path.ChangeExtension(inputFile, "REENC.MP3"),
                                    encoderSettings.Mp3EncoderSettings.GenerateTagsFromTrackMetadata,
                                    ifiSlim);

                                return;
                            }
                    }
                    break;
            }

            throw new NotSupportedException(string.Format("TXT_UNSUPPORTED_TRANSCODING: {0}", this));
        }