Split common and GUI code into separate projects

RedBookPlayer.Common/Hardware/Player.cs

@@ -0,0 +1,432 @@
+using System;
+using System.ComponentModel;
+using Aaru.CommonTypes.Enums;
+using ReactiveUI;
+using RedBookPlayer.Common.Discs;
+
+namespace RedBookPlayer.Common.Hardware
+{
+    public class Player : ReactiveObject
+    {
+        /// <summary>
+        /// Indicate if the player is ready to be used
+        /// </summary>
+        public bool Initialized { get; private set; } = false;
+
+        #region OpticalDisc Passthrough
+
+        /// <summary>
+        /// Current track number
+        /// </summary>
+        public int CurrentTrackNumber
+        {
+            get => _currentTrackNumber;
+            private set => this.RaiseAndSetIfChanged(ref _currentTrackNumber, value);
+        }
+
+        /// <summary>
+        /// Current track index
+        /// </summary>
+        public ushort CurrentTrackIndex
+        {
+            get => _currentTrackIndex;
+            private set => this.RaiseAndSetIfChanged(ref _currentTrackIndex, value);
+        }
+
+        /// <summary>
+        /// Current sector number
+        /// </summary>
+        public ulong CurrentSector
+        {
+            get => _currentSector;
+            private set => this.RaiseAndSetIfChanged(ref _currentSector, value);
+        }
+
+        /// <summary>
+        /// Represents the sector starting the section
+        /// </summary>
+        public ulong SectionStartSector
+        {
+            get => _sectionStartSector;
+            protected set => this.RaiseAndSetIfChanged(ref _sectionStartSector, value);
+        }
+
+        /// <summary>
+        /// Represents if the disc has a hidden track
+        /// </summary>
+        public bool HiddenTrack
+        {
+            get => _hasHiddenTrack;
+            private set => this.RaiseAndSetIfChanged(ref _hasHiddenTrack, value);
+        }
+
+        /// <summary>
+        /// Represents the 4CH flag [CompactDisc only]
+        /// </summary>
+        public bool QuadChannel
+        {
+            get => _quadChannel;
+            private set => this.RaiseAndSetIfChanged(ref _quadChannel, value);
+        }
+
+        /// <summary>
+        /// Represents the DATA flag [CompactDisc only]
+        /// </summary>
+        public bool IsDataTrack
+        {
+            get => _isDataTrack;
+            private set => this.RaiseAndSetIfChanged(ref _isDataTrack, value);
+        }
+
+        /// <summary>
+        /// Represents the DCP flag [CompactDisc only]
+        /// </summary>
+        public bool CopyAllowed
+        {
+            get => _copyAllowed;
+            private set => this.RaiseAndSetIfChanged(ref _copyAllowed, value);
+        }
+
+        /// <summary>
+        /// Represents the PRE flag [CompactDisc only]
+        /// </summary>
+        public bool TrackHasEmphasis
+        {
+            get => _trackHasEmphasis;
+            private set => this.RaiseAndSetIfChanged(ref _trackHasEmphasis, value);
+        }
+
+        /// <summary>
+        /// Represents the total tracks on the disc
+        /// </summary>
+        public int TotalTracks => _opticalDisc.TotalTracks;
+
+        /// <summary>
+        /// Represents the total indices on the disc
+        /// </summary>
+        public int TotalIndexes => _opticalDisc.TotalIndexes;
+
+        /// <summary>
+        /// Total sectors in the image
+        /// </summary>
+        public ulong TotalSectors => _opticalDisc.TotalSectors;
+
+        /// <summary>
+        /// Represents the time adjustment offset for the disc
+        /// </summary>
+        public ulong TimeOffset => _opticalDisc.TimeOffset;
+
+        /// <summary>
+        /// Represents the total playing time for the disc
+        /// </summary>
+        public ulong TotalTime => _opticalDisc.TotalTime;
+
+        private int _currentTrackNumber;
+        private ushort _currentTrackIndex;
+        private ulong _currentSector;
+        private ulong _sectionStartSector;
+
+        private bool _hasHiddenTrack;
+        private bool _quadChannel;
+        private bool _isDataTrack;
+        private bool _copyAllowed;
+        private bool _trackHasEmphasis;
+
+        #endregion
+
+        #region SoundOutput Passthrough
+
+        /// <summary>
+        /// Indicate if the output is playing
+        /// </summary>
+        public bool? Playing
+        {
+            get => _playing;
+            private set => this.RaiseAndSetIfChanged(ref _playing, value);
+        }
+
+        /// <summary>
+        /// Indicates if de-emphasis should be applied
+        /// </summary>
+        public bool ApplyDeEmphasis
+        {
+            get => _applyDeEmphasis;
+            private set => this.RaiseAndSetIfChanged(ref _applyDeEmphasis, value);
+        }
+
+        /// <summary>
+        /// Current playback volume
+        /// </summary>
+        public int Volume
+        {
+            get => _volume;
+            set => this.RaiseAndSetIfChanged(ref _volume, value);
+        }
+
+        private bool? _playing;
+        private bool _applyDeEmphasis;
+        private int _volume;
+
+        #endregion
+
+        #region Private State Variables
+
+        /// <summary>
+        /// Sound output handling class
+        /// </summary>
+        private readonly SoundOutput _soundOutput;
+
+        /// <summary>
+        /// OpticalDisc object
+        /// </summary>
+        private readonly OpticalDisc _opticalDisc;
+
+        #endregion
+
+        /// <summary>
+        /// Create a new Player from a given image path
+        /// </summary>
+        /// <param name="path">Path to the disc image</param>
+        /// <param name="generateMissingToc">Generate a TOC if the disc is missing one [CompactDisc only]</param>
+        /// <param name="loadDataTracks">Load data tracks for playback [CompactDisc only]</param>
+        /// <param name="autoPlay">True if playback should begin immediately, false otherwise</param>
+        /// <param name="defaultVolume">Default volume between 0 and 100 to use when starting playback</param>
+        public Player(string path, bool generateMissingToc, bool loadDataTracks, bool autoPlay, int defaultVolume)
+        {
+            // Set the internal state for initialization
+            Initialized = false;
+            _soundOutput = new SoundOutput();
+            _soundOutput.SetDeEmphasis(false);
+
+            // Initalize the disc
+            _opticalDisc = OpticalDiscFactory.GenerateFromPath(path, generateMissingToc, loadDataTracks, autoPlay);
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            // Add event handling for the optical disc
+            _opticalDisc.PropertyChanged += OpticalDiscStateChanged;
+
+            // Initialize the sound output
+            _soundOutput.Init(_opticalDisc, autoPlay, defaultVolume);
+            if(_soundOutput == null || !_soundOutput.Initialized)
+                return;
+
+            // Add event handling for the sound output
+            _soundOutput.PropertyChanged += SoundOutputStateChanged;
+
+            // Mark the player as ready
+            Initialized = true;
+
+            // Force a refresh of the state information
+            OpticalDiscStateChanged(this, null);
+            SoundOutputStateChanged(this, null);
+        }
+
+        #region Playback
+
+        /// <summary>
+        /// Begin playback
+        /// </summary>
+        public void Play()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+            else if(_soundOutput == null)
+                return;
+            else if(_soundOutput.Playing)
+                return;
+
+            _soundOutput.Play();
+            _opticalDisc.SetTotalIndexes();
+            Playing = true;
+        }
+
+        /// <summary>
+        /// Pause current playback
+        /// </summary>
+        public void Pause()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+            else if(_soundOutput == null)
+                return;
+            else if(!_soundOutput.Playing)
+                return;
+
+            _soundOutput?.Stop();
+            Playing = false;
+        }
+
+        /// <summary>
+        /// Stop current playback
+        /// </summary>
+        public void Stop()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+            else if(_soundOutput == null)
+                return;
+            else if(!_soundOutput.Playing)
+                return;
+
+            _soundOutput?.Stop();
+            _opticalDisc.LoadFirstTrack();
+            Playing = null;
+        }
+
+        /// <summary>
+        /// Move to the next playable track
+        /// </summary>
+        public void NextTrack()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            bool? wasPlaying = Playing;
+            if(wasPlaying == true) Pause();
+
+            _opticalDisc.NextTrack();
+            if(_opticalDisc is CompactDisc compactDisc)
+                _soundOutput.SetDeEmphasis(compactDisc.TrackHasEmphasis);
+
+            if(wasPlaying == true) Play();
+        }
+
+        /// <summary>
+        /// Move to the previous playable track
+        /// </summary>
+        /// <param name="playHiddenTrack">True to play the hidden track, if it exists</param>
+        public void PreviousTrack(bool playHiddenTrack)
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            bool? wasPlaying = Playing;
+            if(wasPlaying == true) Pause();
+
+            _opticalDisc.PreviousTrack(playHiddenTrack);
+            if(_opticalDisc is CompactDisc compactDisc)
+                _soundOutput.SetDeEmphasis(compactDisc.TrackHasEmphasis);
+
+            if(wasPlaying == true) Play();
+        }
+
+        /// <summary>
+        /// Move to the next index
+        /// </summary>
+        /// <param name="changeTrack">True if index changes can trigger a track change, false otherwise</param>
+        public void NextIndex(bool changeTrack)
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            bool? wasPlaying = Playing;
+            if(wasPlaying == true) Pause();
+
+            _opticalDisc.NextIndex(changeTrack);
+            if(_opticalDisc is CompactDisc compactDisc)
+                _soundOutput.SetDeEmphasis(compactDisc.TrackHasEmphasis);
+
+            if(wasPlaying == true) Play();
+        }
+
+        /// <summary>
+        /// Move to the previous index
+        /// </summary>
+        /// <param name="changeTrack">True if index changes can trigger a track change, false otherwise</param>
+        /// <param name="playHiddenTrack">True to play the hidden track, if it exists</param>
+        public void PreviousIndex(bool changeTrack, bool playHiddenTrack)
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            bool? wasPlaying = Playing;
+            if(wasPlaying == true) Pause();
+
+            _opticalDisc.PreviousIndex(changeTrack, playHiddenTrack);
+            if(_opticalDisc is CompactDisc compactDisc)
+                _soundOutput.SetDeEmphasis(compactDisc.TrackHasEmphasis);
+
+            if(wasPlaying == true) Play();
+        }
+
+        /// <summary>
+        /// Fast-forward playback by 75 sectors, if possible
+        /// </summary>
+        public void FastForward()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            _opticalDisc.CurrentSector = Math.Min(_opticalDisc.TotalSectors, _opticalDisc.CurrentSector + 75);
+        }
+
+        /// <summary>
+        /// Rewind playback by 75 sectors, if possible
+        /// </summary>
+        public void Rewind()
+        {
+            if(_opticalDisc == null || !_opticalDisc.Initialized)
+                return;
+
+            if(_opticalDisc.CurrentSector >= 75)
+                _opticalDisc.CurrentSector -= 75;
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Set de-emphasis status
+        /// </summary>
+        /// <param name="apply"></param>
+        public void SetDeEmphasis(bool apply) => _soundOutput?.SetDeEmphasis(apply);
+
+        /// <summary>
+        /// Set the value for loading data tracks [CompactDisc only]
+        /// </summary>
+        /// <param name="load">True to enable loading data tracks, false otherwise</param>
+        public void SetLoadDataTracks(bool load) => (_opticalDisc as CompactDisc)?.SetLoadDataTracks(load);
+
+        /// <summary>
+        /// Update the player from the current OpticalDisc
+        /// </summary>
+        private void OpticalDiscStateChanged(object sender, PropertyChangedEventArgs e)
+        {
+            CurrentTrackNumber = _opticalDisc.CurrentTrackNumber;
+            CurrentTrackIndex = _opticalDisc.CurrentTrackIndex;
+            CurrentSector = _opticalDisc.CurrentSector;
+            SectionStartSector = _opticalDisc.SectionStartSector;
+
+            HiddenTrack = TimeOffset > 150;
+
+            if(_opticalDisc is CompactDisc compactDisc)
+            {
+                QuadChannel = compactDisc.QuadChannel;
+                IsDataTrack = compactDisc.IsDataTrack;
+                CopyAllowed = compactDisc.CopyAllowed;
+                TrackHasEmphasis = compactDisc.TrackHasEmphasis;
+            }
+            else
+            {
+                QuadChannel = false;
+                IsDataTrack = _opticalDisc.TrackType != TrackType.Audio;
+                CopyAllowed = false;
+                TrackHasEmphasis = false;
+            }
+        }
+
+        /// <summary>
+        /// Update the player from the current SoundOutput
+        /// </summary>
+        private void SoundOutputStateChanged(object sender, PropertyChangedEventArgs e)
+        {
+            Playing = _soundOutput.Playing;
+            ApplyDeEmphasis = _soundOutput.ApplyDeEmphasis;
+            Volume = _soundOutput.Volume;
+        }
+
+        #endregion
+    }
+}