Example #1
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="OnDataRead">Call each time data is read</param>
 /// <param name="StartSecond">First second of the track to read, 0 means to start at beginning of the track</param>
 /// <param name="Seconds2Read">Number of seconds to read, 0 means to read until the end of the track</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, uint StartSecond, uint Seconds2Read,
                      CdReadProgressEventHandler ProgressEvent)
 {
     if (TocValid && (track >= Toc.FirstTrack) && (track <= Toc.LastTrack) && (DataReadEvent != null))
     {
         int StartSect = GetStartSector(track);
         int EndSect   = GetEndSector(track);
         if ((StartSect += (int)StartSecond * 75) >= EndSect)
         {
             StartSect -= (int)StartSecond * 75;
         }
         if ((Seconds2Read > 0) && ((int)(StartSect + Seconds2Read * 75) < EndSect))
         {
             EndSect = StartSect + (int)Seconds2Read * 75;
         }
         uint Bytes2Read = (uint)(EndSect - StartSect) * CB_AUDIO;
         uint BytesRead  = 0;
         var  Data       = new byte[CB_AUDIO * NSECTORS];
         bool Cont       = true;
         bool ReadOk     = true;
         if (ProgressEvent != null)
         {
             var rpa = new ReadProgressEventArgs(Bytes2Read, 0);
             ProgressEvent(this, rpa);
             Cont = !rpa.CancelRead;
         }
         for (int sector = StartSect; (sector < EndSect) && (Cont) && (ReadOk); sector += NSECTORS)
         {
             int Sectors2Read = ((sector + NSECTORS) < EndSect) ? NSECTORS : (EndSect - sector);
             ReadOk = ReadSector(sector, Data, Sectors2Read);
             if (ReadOk)
             {
                 var dra = new DataReadEventArgs(Data, (uint)(CB_AUDIO * Sectors2Read));
                 DataReadEvent(this, dra);
                 BytesRead += (uint)(CB_AUDIO * Sectors2Read);
                 if (ProgressEvent != null)
                 {
                     var rpa = new ReadProgressEventArgs(Bytes2Read, BytesRead);
                     ProgressEvent(this, rpa);
                     Cont = !rpa.CancelRead;
                 }
             }
         }
         if (ReadOk)
         {
             return((int)BytesRead);
         }
         else
         {
             return(-1);
         }
     }
     else
     {
         return(-1);
     }
 }
        private void ReadAudioTrack(
            int track, ExtractionPaths paths, ProgressReporter progress)
        {
            Directory.CreateDirectory(paths.OutputDirectory);

            string     outputPath = GenerateOutputPath(paths, track - 1);
            ID3TagData metadata   = GenerateTrackMetadata(track - 1);

            using (var mp3Writer = new LameMP3FileWriter(
                       outputPath, new WaveFormat(), LAMEPreset.STANDARD, metadata))
            {
                CdDataReadEventHandler     onDataRead = (x, y) => OnDataRead(x, y, mp3Writer);
                CdReadProgressEventHandler onProgress = (x, y) => OnTrackProgress(x, y, progress);

                if (m_drive.ReadTrack(track, onDataRead, onProgress) == 0)
                {
                    throw new InvalidOperationException($"Cannot read track {track}");
                }
            }
        }
Example #3
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="Data">Buffer that will receive the data</param>
 /// <param name="DataSize">On return the size needed to read the track</param>
 /// <param name="StartSecond">First second of the track to read, 0 means to start at beginning of the track</param>
 /// <param name="Seconds2Read">Number of seconds to read, 0 means to read until the end of the track</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, uint StartSecond, uint Seconds2Read,
                      CdReadProgressEventHandler ProgressEvent)
 {
     if (TocValid && (track >= Toc.FirstTrack) && (track <= Toc.LastTrack))
     {
         int StartSect = GetStartSector(track);
         int EndSect   = GetEndSector(track);
         if ((StartSect += (int)StartSecond * 75) >= EndSect)
         {
             StartSect -= (int)StartSecond * 75;
         }
         if ((Seconds2Read > 0) && ((int)(StartSect + Seconds2Read * 75) < EndSect))
         {
             EndSect = StartSect + (int)Seconds2Read * 75;
         }
         DataSize = (uint)(EndSect - StartSect) * CB_AUDIO;
         if (Data != null)
         {
             if (Data.Length >= DataSize)
             {
                 CDBufferFiller BufferFiller = new CDBufferFiller(Data);
                 return(ReadTrack(track, new CdDataReadEventHandler(BufferFiller.OnCdDataRead), StartSecond, Seconds2Read,
                                  ProgressEvent));
             }
             else
             {
                 return(0);
             }
         }
         else
         {
             return(0);
         }
     }
     else
     {
         return(-1);
     }
 }
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, uint StartSecond, uint Seconds2Read, CdReadProgressEventHandler ProgressEvent)
 {
     if ((this.TocValid && (track >= this.Toc.FirstTrack)) && (track <= this.Toc.LastTrack))
     {
         int startSector = this.GetStartSector(track);
         int endSector   = this.GetEndSector(track);
         if ((startSector += ((int)(StartSecond * 0x4b))) >= endSector)
         {
             startSector -= (int)(StartSecond * 0x4b);
         }
         if ((Seconds2Read > 0) && ((startSector + ((int)(Seconds2Read * 0x4b))) < endSector))
         {
             endSector = startSector + ((int)(Seconds2Read * 0x4b));
         }
         DataSize = (uint)((endSector - startSector) * 0x930);
         if (Data != null)
         {
             if (Data.Length >= ((int)DataSize))
             {
                 CDBufferFiller filler = new CDBufferFiller(Data);
                 return(this.ReadTrack(track, new CdDataReadEventHandler(filler.OnCdDataRead), StartSecond, Seconds2Read, ProgressEvent));
             }
             return(0);
         }
         return(0);
     }
     return(-1);
 }
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, uint StartSecond, uint Seconds2Read, CdReadProgressEventHandler ProgressEvent)
 {
     if (((this.TocValid && (track >= this.Toc.FirstTrack)) && (track <= this.Toc.LastTrack)) && (DataReadEvent != null))
     {
         ReadProgressEventArgs args;
         int startSector = this.GetStartSector(track);
         int endSector   = this.GetEndSector(track);
         if ((startSector += ((int)(StartSecond * 0x4b))) >= endSector)
         {
             startSector -= (int)(StartSecond * 0x4b);
         }
         if ((Seconds2Read > 0) && ((startSector + ((int)(Seconds2Read * 0x4b))) < endSector))
         {
             endSector = startSector + ((int)(Seconds2Read * 0x4b));
         }
         uint   num3      = (uint)((endSector - startSector) * 0x930);
         uint   bytesread = 0;
         byte[] buffer    = new byte[0x7770];
         bool   flag      = true;
         bool   flag2     = true;
         if (ProgressEvent != null)
         {
             args = new ReadProgressEventArgs(num3, 0);
             ProgressEvent(this, args);
             flag = !args.CancelRead;
         }
         for (int i = startSector; ((i < endSector) && flag) && flag2; i += 13)
         {
             int numSectors = ((i + 13) < endSector) ? 13 : (endSector - i);
             flag2 = this.ReadSector(i, buffer, numSectors);
             if (flag2)
             {
                 DataReadEventArgs ea = new DataReadEventArgs(buffer, (uint)(0x930 * numSectors));
                 DataReadEvent(this, ea);
                 bytesread += (uint)(0x930 * numSectors);
                 if (ProgressEvent != null)
                 {
                     args = new ReadProgressEventArgs(num3, bytesread);
                     ProgressEvent(this, args);
                     flag = !args.CancelRead;
                 }
             }
         }
         if (flag2)
         {
             return((int)bytesread);
         }
         return(-1);
     }
     return(-1);
 }
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, CdReadProgressEventHandler ProgressEvent)
 {
     return(this.ReadTrack(track, Data, ref DataSize, 0, 0, ProgressEvent));
 }
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, CdReadProgressEventHandler ProgressEvent)
 {
     return(this.ReadTrack(track, DataReadEvent, 0, 0, ProgressEvent));
 }
Example #8
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="OnDataRead">Call each time data is read</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, CdReadProgressEventHandler ProgressEvent)
 {
     return ReadTrack(track, DataReadEvent, 0, 0, ProgressEvent);
 }
Example #9
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="OnDataRead">Call each time data is read</param>
 /// <param name="StartSecond">First second of the track to read, 0 means to start at beginning of the track</param>
 /// <param name="Seconds2Read">Number of seconds to read, 0 means to read until the end of the track</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, uint StartSecond, uint Seconds2Read,
                      CdReadProgressEventHandler ProgressEvent)
 {
     if (TocValid && (track >= Toc.FirstTrack) && (track <= Toc.LastTrack) && (DataReadEvent != null))
     {
         int StartSect = GetStartSector(track);
         int EndSect = GetEndSector(track);
         if ((StartSect += (int) StartSecond*75) >= EndSect)
         {
             StartSect -= (int) StartSecond*75;
         }
         if ((Seconds2Read > 0) && ((int) (StartSect + Seconds2Read*75) < EndSect))
         {
             EndSect = StartSect + (int) Seconds2Read*75;
         }
         uint Bytes2Read = (uint) (EndSect - StartSect)*CB_AUDIO;
         uint BytesRead = 0;
         var Data = new byte[CB_AUDIO*NSECTORS];
         bool Cont = true;
         bool ReadOk = true;
         if (ProgressEvent != null)
         {
             var rpa = new ReadProgressEventArgs(Bytes2Read, 0);
             ProgressEvent(this, rpa);
             Cont = !rpa.CancelRead;
         }
         for (int sector = StartSect; (sector < EndSect) && (Cont) && (ReadOk); sector += NSECTORS)
         {
             int Sectors2Read = ((sector + NSECTORS) < EndSect) ? NSECTORS : (EndSect - sector);
             ReadOk = ReadSector(sector, Data, Sectors2Read);
             if (ReadOk)
             {
                 var dra = new DataReadEventArgs(Data, (uint) (CB_AUDIO*Sectors2Read));
                 DataReadEvent(this, dra);
                 BytesRead += (uint) (CB_AUDIO*Sectors2Read);
                 if (ProgressEvent != null)
                 {
                     var rpa = new ReadProgressEventArgs(Bytes2Read, BytesRead);
                     ProgressEvent(this, rpa);
                     Cont = !rpa.CancelRead;
                 }
             }
         }
         if (ReadOk)
         {
             return (int) BytesRead;
         }
         else
         {
             return -1;
         }
     }
     else
     {
         return -1;
     }
 }
Example #10
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="Data">Buffer that will receive the data</param>
 /// <param name="DataSize">On return the size needed to read the track</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, CdReadProgressEventHandler ProgressEvent)
 {
     return ReadTrack(track, Data, ref DataSize, 0, 0, ProgressEvent);
 }
Example #11
0
 /// <summary>
 /// Read the digital data of the track
 /// </summary>
 /// <param name="track">Track to read</param>
 /// <param name="Data">Buffer that will receive the data</param>
 /// <param name="DataSize">On return the size needed to read the track</param>
 /// <param name="StartSecond">First second of the track to read, 0 means to start at beginning of the track</param>
 /// <param name="Seconds2Read">Number of seconds to read, 0 means to read until the end of the track</param>
 /// <param name="OnProgress">Delegate to indicate the reading progress</param>
 /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, uint StartSecond, uint Seconds2Read,
                      CdReadProgressEventHandler ProgressEvent)
 {
     if (TocValid && (track >= Toc.FirstTrack) && (track <= Toc.LastTrack))
     {
         int StartSect = GetStartSector(track);
         int EndSect = GetEndSector(track);
         if ((StartSect += (int) StartSecond*75) >= EndSect)
         {
             StartSect -= (int) StartSecond*75;
         }
         if ((Seconds2Read > 0) && ((int) (StartSect + Seconds2Read*75) < EndSect))
         {
             EndSect = StartSect + (int) Seconds2Read*75;
         }
         DataSize = (uint) (EndSect - StartSect)*CB_AUDIO;
         if (Data != null)
         {
             if (Data.Length >= DataSize)
             {
                 var BufferFiller = new CDBufferFiller(Data);
                 return ReadTrack(track, BufferFiller.OnCdDataRead, StartSecond, Seconds2Read, ProgressEvent);
             }
             else
             {
                 return 0;
             }
         }
         else
         {
             return 0;
         }
     }
     else
     {
         return -1;
     }
 }
Example #12
0
 public int ReadTrack(int track, byte[] Data, ref uint DataSize, uint StartSecond, uint Seconds2Read, CdReadProgressEventHandler ProgressEvent)
 {
     if ((this.TocValid && (track >= this.Toc.FirstTrack)) && (track <= this.Toc.LastTrack))
     {
         int startSector = this.GetStartSector(track);
         int endSector = this.GetEndSector(track);
         if ((startSector += ((int)(StartSecond * 0x4b))) >= endSector)
         {
             startSector -= (int)(StartSecond * 0x4b);
         }
         if ((Seconds2Read > 0) && ((startSector + ((int)(Seconds2Read * 0x4b))) < endSector))
         {
             endSector = startSector + ((int)(Seconds2Read * 0x4b));
         }
         DataSize = (uint)((endSector - startSector) * 0x930);
         if (Data != null)
         {
             if (Data.Length >= ((int)DataSize))
             {
                 CDBufferFiller filler = new CDBufferFiller(Data);
                 return this.ReadTrack(track, new CdDataReadEventHandler(filler.OnCdDataRead), StartSecond, Seconds2Read, ProgressEvent);
             }
             return 0;
         }
         return 0;
     }
     return -1;
 }
Example #13
0
 public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, uint StartSecond, uint Seconds2Read, CdReadProgressEventHandler ProgressEvent)
 {
     if (((this.TocValid && (track >= this.Toc.FirstTrack)) && (track <= this.Toc.LastTrack)) && (DataReadEvent != null))
     {
         ReadProgressEventArgs args;
         int startSector = this.GetStartSector(track);
         int endSector = this.GetEndSector(track);
         if ((startSector += ((int)(StartSecond * 0x4b))) >= endSector)
         {
             startSector -= (int)(StartSecond * 0x4b);
         }
         if ((Seconds2Read > 0) && ((startSector + ((int)(Seconds2Read * 0x4b))) < endSector))
         {
             endSector = startSector + ((int)(Seconds2Read * 0x4b));
         }
         uint num3 = (uint)((endSector - startSector) * 0x930);
         uint bytesread = 0;
         byte[] buffer = new byte[0x7770];
         bool flag = true;
         bool flag2 = true;
         if (ProgressEvent != null)
         {
             args = new ReadProgressEventArgs(num3, 0);
             ProgressEvent(this, args);
             flag = !args.CancelRead;
         }
         for (int i = startSector; ((i < endSector) && flag) && flag2; i += 13)
         {
             int numSectors = ((i + 13) < endSector) ? 13 : (endSector - i);
             flag2 = this.ReadSector(i, buffer, numSectors);
             if (flag2)
             {
                 DataReadEventArgs ea = new DataReadEventArgs(buffer, (uint)(0x930 * numSectors));
                 DataReadEvent(this, ea);
                 bytesread += (uint)(0x930 * numSectors);
                 if (ProgressEvent != null)
                 {
                     args = new ReadProgressEventArgs(num3, bytesread);
                     ProgressEvent(this, args);
                     flag = !args.CancelRead;
                 }
             }
         }
         if (flag2)
         {
             return (int)bytesread;
         }
         return -1;
     }
     return -1;
 }
Example #14
0
        /// <summary>
        /// Read the digital data of the track
        /// </summary>
        /// <param name="track">Track to read</param>
        /// <param name="OnDataRead">Call each time data is read</param>
        /// <param name="StartSecond">First second of the track to read, 0 means to start at beginning of the track</param>
        /// <param name="Seconds2Read">Number of seconds to read, 0 means to read until the end of the track</param>
        /// <param name="OnProgress">Delegate to indicate the reading progress</param>
        /// <returns>Negative value means an error. On success returns the number of bytes read</returns>
        public int ReadTrack(int track, CdDataReadEventHandler DataReadEvent, uint StartSecond, uint Seconds2Read, CdReadProgressEventHandler ProgressEvent)
        {
            if (TocValid && (track >= Toc.FirstTrack) && (track <= Toc.LastTrack) && (DataReadEvent != null))
            {
                int StartSect = GetStartSector(track);
                int EndSect   = GetEndSector(track);
                if ((StartSect += (int)StartSecond * 75) >= EndSect)
                {
                    StartSect -= (int)StartSecond * 75;
                }
                if ((Seconds2Read > 0) && ((int)(StartSect + Seconds2Read * 75) < EndSect))
                {
                    EndSect = StartSect + (int)Seconds2Read * 75;
                }
                uint   Bytes2Read = (uint)(EndSect - StartSect) * CB_AUDIO;
                uint   BytesRead  = 0;
                byte[] Data       = new byte[CB_AUDIO * NSECTORS];
                bool   Cont       = true;
                bool   ReadOk     = true;
                if (ProgressEvent != null)
                {
                    ReadProgressEventArgs rpa = new ReadProgressEventArgs(Bytes2Read, 0);
                    ProgressEvent(this, rpa);
                    Cont = !rpa.CancelRead;
                }

                /////////////START NORMALISIEREN
                // Normalisieren?
                double normFactor = 0;
                int    maxValue   = 0;
                if (Big3.Hitbase.Configuration.Settings.Current.NormalizeActive)
                {
                    for (int sector = StartSect; (sector < EndSect) && (Cont) && (ReadOk); sector += NSECTORS)
                    {
                        int Sectors2Read = ((sector + NSECTORS) < EndSect) ? NSECTORS : (EndSect - sector);
                        ReadOk = ReadSector(sector, Data, Sectors2Read);
                        if (ReadOk)
                        {
                            BytesRead += (uint)(CB_AUDIO * Sectors2Read);

                            for (int i = 0; i < Data.Length; i += 2)
                            {
                                int intValue = (int)(short)(Data[i + 1] * 256 + Data[i]);
                                if (Math.Abs(intValue) > maxValue)
                                {
                                    maxValue = Math.Abs(intValue);
                                }
                            }

                            if (ProgressEvent != null)
                            {
                                ReadProgressEventArgs rpa = new ReadProgressEventArgs(Bytes2Read, BytesRead);
                                ProgressEvent(this, rpa);
                                Cont = !rpa.CancelRead;
                            }
                        }
                    }

                    normFactor = 32768.0 / (double)maxValue;
                }
                /////////////ENDE NORMALISIEREN


                BytesRead = 0;

                for (int sector = StartSect; (sector < EndSect) && (Cont) && (ReadOk); sector += NSECTORS)
                {
                    int Sectors2Read = ((sector + NSECTORS) < EndSect) ? NSECTORS : (EndSect - sector);
                    ReadOk = ReadSector(sector, Data, Sectors2Read);
                    if (ReadOk)
                    {
                        if (Big3.Hitbase.Configuration.Settings.Current.NormalizeActive)
                        {
                            for (int i = 0; i < Data.Length; i += 2)
                            {
                                int    intValue        = (int)(short)(Data[i + 1] * 256 + Data[i]);
                                int    normalizedValue = (int)((double)intValue * normFactor);
                                byte[] shortValues     = BitConverter.GetBytes((short)normalizedValue);
                                Data[i + 1] = shortValues[1];
                                Data[i]     = shortValues[0];
                            }
                        }


                        DataReadEventArgs dra = new DataReadEventArgs(Data, (uint)(CB_AUDIO * Sectors2Read));
                        DataReadEvent(this, dra);
                        BytesRead += (uint)(CB_AUDIO * Sectors2Read);
                        if (ProgressEvent != null)
                        {
                            ReadProgressEventArgs rpa = new ReadProgressEventArgs(Bytes2Read, BytesRead);
                            ProgressEvent(this, rpa);
                            Cont = !rpa.CancelRead;
                        }
                    }
                }
                if (ReadOk)
                {
                    return((int)BytesRead);
                }
                else
                {
                    return(-1);
                }
            }
            else
            {
                return(-1);
            }
        }