private int SetupResultPcm(AudioData from,  List<FilterBase> filters, out AudioData to, FileFormatType toFileFormat)
        {
            to = new AudioData();
            to.preferredSaveFormat = toFileFormat;

            var fmt = FilterSetup(from, 0, filters);

            to.meta = new WWFlacRWCS.Metadata(from.meta);
            to.meta.sampleRate = fmt.SampleRate;
            to.meta.totalSamples = fmt.NumSamples;
            to.meta.channels = fmt.NumChannels;

            switch (toFileFormat) {
            case FileFormatType.FLAC:
            #if true
            to.meta.bitsPerSample = 24;
            #endif
            break;
            case FileFormatType.DSF:
            to.meta.bitsPerSample = 1;
            break;
            }

            if (from.picture != null) {
                to.picture = new byte[from.picture.Length];
                System.Array.Copy(from.picture, to.picture, to.picture.Length);
            }

            // allocate "to" pcm data
            to.pcm = new List<AudioDataPerChannel>();
            for (int ch = 0; ch < to.meta.channels; ++ch) {
                byte[] data;

                // set silent sample values to output buffer
                switch (toFileFormat) {
                case FileFormatType.DSF:
                if (0x7FFFFFC7 < (to.meta.totalSamples + 7) / 8) {
                    return (int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge;
                }
                data = new byte[(to.meta.totalSamples + 7) / 8];
                for (long i = 0; i < data.LongLength; ++i) {
                    data[i] = 0x69;
                }
                break;
                case FileFormatType.FLAC:
                if (0x7FFFFFC7 < to.meta.totalSamples * (to.meta.bitsPerSample / 8)) {
                    return (int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge;
                }
                data = new byte[to.meta.totalSamples * (to.meta.bitsPerSample / 8)];
                break;
                default:
                System.Diagnostics.Debug.Assert(false);
                data = null;
                break;
                }

                var adp = new AudioDataPerChannel();
                adp.data = data;
                adp.bitsPerSample = to.meta.bitsPerSample;
                adp.totalSamples = to.meta.totalSamples;
                to.pcm.Add(adp);
            }
            return 0;
        }
Exemple #2
0
        private int SetupResultPcm(AudioData from, List <FilterBase> filters, out AudioData to, FileFormatType toFileFormat)
        {
            to = new AudioData();
            to.preferredSaveFormat = toFileFormat;

            var fmt = FilterSetup(from, 0, filters);

            to.meta              = new WWFlacRWCS.Metadata(from.meta);
            to.meta.sampleRate   = fmt.SampleRate;
            to.meta.totalSamples = fmt.NumSamples;
            to.meta.channels     = fmt.NumChannels;

            switch (toFileFormat)
            {
            case FileFormatType.FLAC:
#if true
                to.meta.bitsPerSample = 24;
#endif
                break;

            case FileFormatType.DSF:
                to.meta.bitsPerSample = 1;
                break;
            }

            if (from.picture != null)
            {
                to.picture = new byte[from.picture.Length];
                System.Array.Copy(from.picture, to.picture, to.picture.Length);
            }

            // allocate "to" pcm data
            to.pcm = new List <AudioDataPerChannel>();
            for (int ch = 0; ch < to.meta.channels; ++ch)
            {
                byte[] data;

                // set silent sample values to output buffer
                switch (toFileFormat)
                {
                case FileFormatType.DSF:
                    if (0x7FFFFFC7 < (to.meta.totalSamples + 7) / 8)
                    {
                        return((int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge);
                    }
                    data = new byte[(to.meta.totalSamples + 7) / 8];
                    for (long i = 0; i < data.LongLength; ++i)
                    {
                        data[i] = 0x69;
                    }
                    break;

                case FileFormatType.FLAC:
                    if (0x7FFFFFC7 < to.meta.totalSamples * (to.meta.bitsPerSample / 8))
                    {
                        return((int)WWFlacRWCS.FlacErrorCode.OutputFileTooLarge);
                    }
                    data = new byte[to.meta.totalSamples * (to.meta.bitsPerSample / 8)];
                    break;

                default:
                    System.Diagnostics.Debug.Assert(false);
                    data = null;
                    break;
                }

                var adp = new AudioDataPerChannel();
                adp.data          = data;
                adp.bitsPerSample = to.meta.bitsPerSample;
                adp.totalSamples  = to.meta.totalSamples;
                to.pcm.Add(adp);
            }
            return(0);
        }
        private static int WriteFlacFile(ref AudioData ad, string path)
        {
            int rv;
            var flac = new WWFlacRWCS.FlacRW();
            rv = flac.EncodeInit(ad.meta);
            if (rv < 0) {
                return rv;
            }

            rv = flac.EncodeSetPicture(ad.picture);
            if (rv < 0) {
                flac.EncodeEnd();
                return rv;
            }

            for (int ch = 0; ch < ad.meta.channels; ++ch) {
                long lrv = flac.EncodeAddPcm(ch, ad.pcm[ch].data);
                if (lrv < 0) {
                    flac.EncodeEnd();
                    return (int)lrv;
                }
            }

            rv = flac.EncodeRun(path);
            if (rv < 0) {
                flac.EncodeEnd();
                return rv;
            }

            flac.EncodeEnd();
            return 0;
        }
        private static int WriteDsfFile(ref AudioData ad, string path)
        {
            int rv;
            var dsf = new WWDsfWriter();

            rv = dsf.EncodeInit(ad.meta);
            if (rv < 0) {
                return rv;
            }

            rv = dsf.EncodeSetPicture(ad.picture);
            if (rv < 0) {
                dsf.EncodeEnd();
                return rv;
            }

            for (int ch = 0; ch < ad.meta.channels; ++ch) {
                long lrv = dsf.EncodeAddPcm(ch, ad.pcm[ch].data);
                if (lrv < 0) {
                    dsf.EncodeEnd();
                    return (int)lrv;
                }
            }

            rv = dsf.EncodeRun(path);
            if (rv < 0) {
                dsf.EncodeEnd();
                return rv;
            }

            dsf.EncodeEnd();
            return 0;
        }
        private static int ReadWavFile(string path, out AudioData ad)
        {
            ad = new AudioData();

            using (var br = new BinaryReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))) {
                var reader = new WavRWLib2.WavReader();
                if (!reader.ReadHeaderAndSamples(br, 0, -1)) {
                    MessageBox.Show(
                        string.Format("Error: Failed to read WAV file: {0}", path));
                    return -1;
                }

                ad.meta = new WWFlacRWCS.Metadata();
                ad.meta.albumStr = reader.AlbumName;
                ad.meta.artistStr = reader.ArtistName;
                ad.meta.titleStr = reader.Title;
                ad.meta.pictureBytes = reader.PictureBytes;
                ad.picture = reader.PictureData;
                ad.meta.totalSamples = reader.NumFrames;
                ad.meta.channels = reader.NumChannels;
                ad.meta.sampleRate = reader.SampleRate;

                var interleaved = reader.GetSampleArray();
                int bytesPerSample = reader.BitsPerSample / 8;

                ad.pcm = new List<AudioDataPerChannel>();
                for (int ch = 0; ch < reader.NumChannels; ++ch) {

                    var pcmOneChannel = new byte[reader.NumFrames * bytesPerSample];
                    for (int i = 0; i < reader.NumFrames; ++i) {
                        for (int b = 0; b < reader.BitsPerSample / 8; ++b) {
                            pcmOneChannel[bytesPerSample * i + b] =
                                interleaved[bytesPerSample * (reader.NumChannels * i + ch) + b];
                        }
                    }

                    var pcm24 = PcmDataLib.Util.ConvertTo24bit(reader.BitsPerSample, reader.NumFrames, reader.SampleValueRepresentationType, pcmOneChannel);

                    var adp = new AudioDataPerChannel();
                    adp.data = pcm24;
                    adp.offsBytes = 0;
                    adp.bitsPerSample = 24;
                    adp.totalSamples = ad.meta.totalSamples;
                    ad.pcm.Add(adp);
                }

                // converted to 24bit
                ad.meta.bitsPerSample = 24;
                ad.preferredSaveFormat = FileFormatType.FLAC;
                return 0;
            }
        }
        private static int ReadFlacFile(string path, out AudioData ad)
        {
            ad = new AudioData();

            var flac = new WWFlacRWCS.FlacRW();
            int rv = flac.DecodeAll(path);
            if (rv < 0) {
                return rv;
            }

            rv = flac.GetDecodedMetadata(out ad.meta);
            if (rv < 0) {
                return rv;
            }

            rv = flac.GetDecodedPicture(out ad.picture, ad.meta.pictureBytes);
            if (rv < 0) {
                return rv;
            }

            ad.pcm = new List<AudioDataPerChannel>();
            for (int ch = 0; ch < ad.meta.channels; ++ch) {
                byte[] pcm;
                long lrv = flac.GetDecodedPcmBytes(ch, 0, out pcm, ad.meta.totalSamples * (ad.meta.bitsPerSample / 8));
                if (lrv < 0) {
                    return (int)lrv;
                }

                var pcm24 = PcmDataLib.Util.ConvertTo24bit(ad.meta.bitsPerSample, ad.meta.totalSamples, PcmDataLib.PcmData.ValueRepresentationType.SInt, pcm);

                var adp = new AudioDataPerChannel();
                adp.data = pcm24;
                adp.offsBytes = 0;
                adp.bitsPerSample = 24;
                adp.totalSamples = ad.meta.totalSamples;
                ad.pcm.Add(adp);
            }

            // converted to 24bit
            ad.meta.bitsPerSample = 24;
            ad.preferredSaveFormat = FileFormatType.FLAC;

            flac.DecodeEnd();

            return 0;
        }
 private static PcmFormat FilterSetup(AudioData from, int ch, List<FilterBase> filters)
 {
     var fmt = new PcmFormat(from.meta.channels, ch, from.meta.sampleRate, from.meta.totalSamples);
     foreach (var f in filters) {
         fmt = f.Setup(fmt);
     }
     return fmt;
 }