Merge pull request #2 from bitkeeper/v1.x

Merge v1.x develop to main

Author: bitkeeper

README.MD

@@ -2,6 +2,8 @@ MPD2CamillaDSPVolume<!-- omit in toc -->
 =============================================
 bitkeeper @ github 2022
 
+Starting from mpd2cdspvolume version `1.0.0` support for camilladsp 1.x is dropped. With that also the command `cdspstorevolume` is dropped.
+
 # Introduction
 
 [MPD2CamillaDSPVolume](https://github.com/bitkeeper/mpd2cdspvolume) makes it possible to control the volume of CamillaDSP with the volume of MPD.
@@ -16,26 +18,19 @@ Features:
 
 How it works:
 * It listens to MPD Mixer changes.
-* When CamillaDSP is running, the changed volume is send to CamillaDSP else to the state file.
+* When CamillaDSP is running, the changed volume is send to CamillaDSP else to the statefile.
 
 Requires:
-* Using for MPD volume control the mixer type `null`
-* Use in the alsa_cdsp config the `camilla_exit_cmd` to make sure the volume is writen on exit.
-```
-camilla_exit_cmd "/usr/local/bin/cdspstorevolume"
-```
-* The camilla_exit_cmd requires that the process of alsa_cdsp can send signals to MPD2CamillaDSPVolume (most easy to run both as the same user)
+* Add in alsa_cdsp config for the `cargs` the argument to the correct statefile ` -s <path_t_your_statefile>` to start camilladsp with the correct statefile.
+* Use the same statefile with mpd2cdspvolume.
 
 
-When using MPD with CamillaDSP the volume of MPD isn't coupled to CamillaDSP.
-
 # Files
 ## From source
 
 | File    |      Description    | Packed  as |
 |----------  |-----------------|---------------|
 | mpd2cdspvolume.py       | mpd volume to camilladsp syncer                           | /usr/local/bin/mpd2cdspvolume |
-| cdspstorevolume.sh      | store the current cdsp volume in to the volume state file | /usr/local/bin/cdspstorevolume.sh |
 | etc/mpd2cdspvolume.conf | tmpfs files to created                                    | /usr/lib/tmpfiles.d/mpd2cdspvolume.conf |
 | etc/mpd2cdspvolume.service | systemd service file                                   | /lib/systemd/system/mpd2cdspvolume.service |
 | etc/mpd2cdspvolume.config | mpd2cdspvolume config file*                                  | /etc/mpd2cdspvolume.config
@@ -48,7 +43,8 @@ When using MPD with CamillaDSP the volume of MPD isn't coupled to CamillaDSP.
 | File    |      Description    |
 |----------  |-----------------|
 | /var/run/mpd2cdspvol/mpd2cdspvol.pid | Contains PID of mpd2cdspvolume. Path is in a temp.fs and is created on boot by `usr/lib/tmpfiles.d/mpd2cdspvolume.conf` |
-| /var/lib/cdsp/camilladsp_volume_state| Contains the volume_state as required by alsa_cdsp. Path is postinstall.sh (typical runned on deb install time)|
+| /var/lib/cdsp/statefile.yml | Contains the volume_state as required by camilladsp. Path is postinstall.sh (typical runned on deb install time)|
+
 # Install
 
 
@@ -68,7 +64,6 @@ Copy the scripts to a convient location like:
 ```bash
 sudo cp mpd2cdspvolume.py /usr/local/bin/mpd2cdspvolume
 sudo chmod a+x /usr/local/bin/mpd2cdspvolume
-sudo cp cdspstorevolume.sh /usr/local/bin/cdspstorevolume
 sudo chmod a+x /usr/local/bin/cdspstorevolume
 sudo cp etc/mpd2cdspvolume.conf usr/lib/tmpfiles.d/
 ```
@@ -105,12 +100,6 @@ optional arguments:
 
 example:
 
-with camilladsp 1.x
-```bash
-sudo -H -u mpd bash -c "/usr/local/bin/mpd2cdspvolume --verbose --pid_file /var/run/mpd2cdspvol/mpd2cdspvol.pid --volume_state_file /var/lib/cdsp/camilladsp_volume_state --config /etc/mpd2cdspvolume.config"
-```
-
-with camilladsp 2.x
 ```bash
 sudo -H -u mpd bash -c "/usr/local/bin/mpd2cdspvolume --verbose --pid_file /var/run/mpd2cdspvol/mpd2cdspvol.pid --volume_state_file /var/lib/cdsp/statefile.yml --config /etc/mpd2cdspvolume.config"
 ```
@@ -120,22 +109,20 @@ This will run the program as user `mpd` and with `--verbose` show output of the
 When also  [alsa_cdsp](https://github.com/scripple/alsa_cdsp) is used, alsa_cdsp start and stop camilladsp on source change like samplerate. Also when music is pauzed camilladsp is stopped. [moOde](https://www.moode.org) is an example that uses alsa_cdsp
 
 To preserve the volume settings of camilladsp alsa_cdsp a way of using a volume state file:
-- Before camilladsp is started, the state file is read and volume is supplied as argument to camilladsp
-- Just before shutting down camilladsp an 'exit' command can be executed to store the volume.
-
-
-When a SIGHUP signal is send to mpd2cdspvolume it read the current volume setting of camilladsp and write it to file.
+- camilladsp gets and argument at startup with the used statefile
 
-Md2cdspvolume provides and script `cdspstorevolume` that can be use as 'exit' command, that send the SIGHUP to `mpd2cdspvolume` script.
 
 When MPD volume changes are made, while the music isn't playing or camilladsp isn't active, the volume setting is writen to the state file instead.
 
 To use the state file with alsa_cdsp edit the config and add the `vol_file` and `camilla_exit_cmd` arguments.
 
 For example with moOde add following lines to `/etc/alsa/conf.d/camilladsp.conf`:
 ```bash
-    vol_file "/var/lib/cdsp/camilladsp_volume_state"
-    camilla_exit_cmd "/usr/local/bin/cdspstorevolume"
+   cargs [
+        -p "1234"
+        -a "0.0.0.0"
+        -s "/var/lib/cdsp/statefile.yml"
+   ]
 ```
 
 To make this work the user of the process who is running should have the rights to send a signal to mpd2cdspvolume.

builddep.sh

@@ -16,7 +16,7 @@ fi
 
 if [ -z "$PKGVERSION" ]
 then
-PKGVERSION="0.4.0"
+PKGVERSION="1.0.0"
 fi
 
 if [ -z "$DEBVER" ]
@@ -33,14 +33,12 @@ fi
 # Prep root to pack
 mkdir -p root/usr/local/bin
 cp mpd2cdspvolume.py root/usr/local/bin/mpd2cdspvolume
-cp cdspstorevolume.sh root/usr/local/bin/cdspstorevolume
 mkdir -p root/usr/lib/tmpfiles.d
 cp etc/mpd2cdspvolume.conf root/usr/lib/tmpfiles.d/
 mkdir -p root/etc
 cp etc/mpd2cdspvolume.config root/etc
 
 chmod a+x root/usr/local/bin/mpd2cdspvolume
-chmod a+x root/usr/local/bin/cdspstorevolume
 
 # build the package
 fpm -s dir -t deb -n $PKGNAME -v $PKGVERSION \
@@ -56,7 +54,7 @@ fpm -s dir -t deb -n $PKGNAME -v $PKGVERSION \
 --description "Service for synchronizing MPD volume to CamillaDSP." \
 --deb-systemd etc/mpd2cdspvolume.service \
 --depends python3-mpd2 \
---depends python3-camilladsp \
+--depends 'python3-camilladsp >= 2.0.0' \
 --after-install etc/postinstall.sh \
 root/usr/=/usr/. \
 root/etc/=/etc/.

cdspstorevolume.sh

@@ -1,3 +1,10 @@
+1.0.0
+* [refactor!] Drop support Camilladsp 1.x
+* [fix] Correct initial statefile generation
+* [feat] Create correct statefile if format is not valid
+* [feat] Detect if correct camilladsp python pacakge is installed
+* [refactor] Don't store volume on sighup (not required any more with CamillaDSP)
+
 0.4.0
 * Support for Camilladsp 2.0
 

changelog.txt

@@ -40,12 +40,9 @@
 from math import log10, exp, log
 from mpd import MPDClient, ConnectionError
 
-try:
-    from camilladsp import CamillaClient
-except:
-    from camilladsp import CamillaConnection as CamillaClient
+import camilladsp
 
-VERSION = "0.4.0"
+VERSION = "1.0.0"
 
 def lin_vol_curve(perc: int, dynamic_range: float= 60.0) -> float:
     '''
@@ -147,92 +144,79 @@ class CamillaDSPVolumeUpdater:
     """Updates CamillaDSP volume
        When cdsp isn't running and a volume state file for alsa_cdsp is provided that one is updated
     """
+
+    CDSP_STATE_TEMPLATE = {
+            'config_path': '/usr/share/camilladsp/working_config.yml',
+            'mute': [ False,False, False,False,False],
+            'volume': [ -6.0, -6.0, -6.0, -6.0, -6.0]
+    }
+    """ Used as default statefile value, when not present or invalid"""
+
     def __init__(self, volume_state_file: Optional[Path] = None, host: str='127.0.0.1', port:int=1234):
         self._volume_state_file: Optional[Path]= volume_state_file
-        self._cdsp = CamillaClient(host, port)
+        self._cdsp = camilladsp.CamillaClient(host, port)
         if volume_state_file:
             logging.info('volume state file: "%s"', volume_state_file )
 
-    def update_alsa_cdsp_volume_file(self, volume_db: float, mute: int=0):
-        """ Store state in own mpd2cdspvolume statefile. Required for CamillaDSP < 2.x"""
-        if self._volume_state_file and self._volume_state_file.exists():
-            logging.info('update volume state file : %.2f dB, mute: %d', volume_db,mute)
-            try:
-                self._volume_state_file.write_text('{} {}'.format(volume_db, mute))
-            except FileNotFoundError as e:
-                logging.error('Couldn\'t create state file "%s", prob basedir doesn\'t exists.', self._volume_state_file)
-            except PermissionError as e:
-                logging.error('Couldn\'t write state to "%s", prob incorrect owner rights of dir.', self._volume_state_file)
+    def check_cdsp_statefile(self) -> bool:
+        """ check if it exists and is valid. If not create a valid one"""
+        try:
+            if self._volume_state_file and self._volume_state_file.is_file() is False:
+                logging.info('Create statefile %s',self._volume_state_file)
+                cdsp.update_cdsp_statefile(0, False)
+            elif self._volume_state_file.is_file() is True:
+                cdsp_state = yaml.load(self._volume_state_file.read_text(), Loader=yaml.Loader)
+                if isinstance(cdsp_state, dict) is False:
+                    logging.info('Statefile %s content not valid recreate it',self._volume_state_file)
+                    cdsp.update_cdsp_statefile(0, False)
+        except FileNotFoundError as e:
+            logging.error('Couldn\'t create state file "%s", prob basedir doesn\'t exists.', self._volume_state_file)
+            return False
+        except PermissionError as e:
+            logging.error('Couldn\'t write state to "%s", prob incorrect owner rights of dir.', self._volume_state_file)
+            return False
+
+        return True
 
     def update_cdsp_volume(self, volume_db: float):
         try:
             if self._cdsp.is_connected() is False:
                 self._cdsp.connect()
 
+            self._cdsp.volume.set_main(volume_db)
+            time.sleep(0.2)
+            cdsp_actual_volume = self._cdsp.volume.main()
+            logging.info('volume set to %.2f [readback = %.2f] dB', volume_db, cdsp_actual_volume)
 
-            if hasattr(self._cdsp, "volume"):
+            # correct issue when volume is not the required one (issue with cdsp 2.0)
+            if abs(cdsp_actual_volume-volume_db) > .2:
+                # logging.info('volume incorrect !')
                 self._cdsp.volume.set_main(volume_db)
-                time.sleep(0.2)
-                cdsp_actual_volume = self._cdsp.volume.main()
-                logging.info('volume set to %.2f [readback = %.2f] dB', volume_db, cdsp_actual_volume)
-
-                # correct issue when volume is not the required one (issue with cdsp 2.0)
-                if abs(cdsp_actual_volume-volume_db) > .2:
-                    # logging.info('volume incorrect !')
-                    self._cdsp.volume.set_main(volume_db)
-            else:
-                self._cdsp.set_volume(volume_db)
             return True
         except (ConnectionRefusedError, IOError) as e:
             logging.info('no cdsp')
-            if hasattr(self._cdsp, "volume"):
-                self.update_alsa_cdsp_volume_file(volume_db)
-            else:
-                self.update_cdsp_statefile(volume_db)
+            self.update_cdsp_statefile(volume_db)
             return False
 
-    def store_volume(self):
-        try:
-            if self._cdsp.is_connected() is False:
-                self._cdsp.connect()
-
-            if hasattr(self._cdsp, "volume"):
-                volume_db = float(self._cdsp.volume.main())
-                mute = 1 if self._cdsp.mute.main() else 0
-            else:
-                volume_db = float(self._cdsp.get_volume())
-                mute = 1 if self._cdsp.get_mute() else 0
-            self.update_alsa_cdsp_volume_file(volume_db, mute)
-
-        except (ConnectionRefusedError, IOError) as e:
-            logging.warning('store volume: no cdsp')
-
-    def sig_hup(self, signum, frame):
-        if hasattr(self._cdsp, "volume") is False:
-            self.store_volume()
-        # force disconnect to prevent a 'hanging' socket during close down of cdsp
-        if self._cdsp.is_connected():
-            self._cdsp.disconnect()
-
     def update_cdsp_statefile(self, main_volume: float=-6.0, main_mute:bool = False):
         """ Update statefile from camilladsp. Used for CamillaDSP 2.x and higher."""
         logging.info('update volume state file : %.2f dB, mute: %d', main_volume ,main_mute)
-        cdsp_state = {
-            'config_path': '/usr/share/camilladsp/working_config.yml',
-            'mute': [ False,False, False,False,False],
-            'volume': [ -6.0, -6.0, -6.0, -6.0, -6.0]
-}
+        cdsp_state = dict(CamillaDSPVolumeUpdater.CDSP_STATE_TEMPLATE)
         if self._volume_state_file:
             try:
                 if self._volume_state_file.exists():
-                    cdsp_state = yaml.load(self._volume_state_file.read_text(), Loader=yaml.Loader)
+                    data = yaml.load(self._volume_state_file.read_text(), Loader=yaml.Loader)
+                    if isinstance(data, dict):
+                        cdsp_state = data
+                    else:
+                        logging.warning('no valid state file content, overwrite it')
                 else:
                     logging.info('no state file present, create one')
 
                 cdsp_state['volume'][0] = main_volume
                 cdsp_state['mute'][0] = main_mute
 
-                self._volume_state_file.write_text(yaml.dump(data, indent=8, explicit_start=True))
+                self._volume_state_file.write_text(yaml.dump(cdsp_state, indent=8, explicit_start=True))
             except FileNotFoundError as e:
                 logging.error('Couldn\'t create state file "%s", prob basedir doesn\'t exists.', self._volume_state_file)
             except PermissionError as e:
@@ -285,6 +269,10 @@ def get_config(config_file: Path):
     if args.verbose:
         logging.basicConfig(level=logging.INFO)
 
+    if not hasattr(camilladsp, 'CamillaClient'):
+            logging.error('No or wrong version of Python package camilladsp installed, requires version 2 or higher.')
+            exit(1)
+
     logging.info('start-up mpd2cdspvolume')
 
     dynamic_range : Optional[int]= None
@@ -313,24 +301,13 @@ def get_config(config_file: Path):
 
 
     state_file = args.volume_state_file
-    if state_file and state_file.is_file() is False:
-        logging.info('Create statefile %s',state_file)
-        try:
-            state_file.write_text('0 0')
-        except FileNotFoundError as e:
-            logging.error('Couldn\'t create state file "%s", prob basedir doesn\'t exists.', state_file)
-            exit(1)
-        except PermissionError as e:
-            logging.error('Couldn\'t write state to "%s", prob incorrect owner rights of dir.', state_file)
-            exit(1)
-
-
     cdsp = CamillaDSPVolumeUpdater(state_file, host = args.cdsp_host, port = args.cdsp_port)
+    if cdsp.check_cdsp_statefile() is False:
+        exit(1)
     monitor = MPDMixerMonitor(host = args.mpd_host, port = args.mpd_port, callback = cdsp.update_cdsp_volume, dynamic_range=dynamic_range, volume_offset=volume_offset)
 
     signal.signal(signal.SIGINT, monitor.exit_gracefully)
     signal.signal(signal.SIGTERM, monitor.exit_gracefully)
-    signal.signal(signal.SIGHUP, cdsp.sig_hup)
 
     monitor.run_monitor()