make audio compression optional via API param on POST speakers/ request so that we can optionally use the aggressive compression which makes sense for uploads from mobile devices, but not for admin uploads

Author: hburgund

roundware/api2/tests/test_audio_normalization.py

@@ -327,4 +327,215 @@ def test_speakers_api_integration_disabled(self, temp_dir):
                 mock_convert.assert_called_once()
 
                 # Should return the expected URL (with timestamp in filename)
-                assert ".mp3" in result 
+                assert ".mp3" in result 
+
+
+class TestAudioCompressionParameter:
+    """Test cases for the new audio_compression parameter functionality"""
+
+    def test_convert_uploaded_file_compression_disabled(self, temp_dir, test_audio_file):
+        """Test convert_uploaded_file with compression explicitly disabled"""
+        filename = "test_audio.wav"
+        test_audio_file(filename)
+        
+        with patch('roundware.lib.convertaudio.compress_audio_file') as mock_compress:
+            with patch('roundware.lib.convertaudio.normalize_audio_file') as mock_normalize:
+                with patch('roundware.lib.convertaudio.convert_audio_file') as mock_convert:
+                    mock_convert.return_value = None
+                    
+                    result = convert_uploaded_file(filename, enable_compression=False)
+                    
+                    # Compression should NOT be called
+                    mock_compress.assert_not_called()
+                    
+                    # Normalization should still be called
+                    mock_normalize.assert_called_once()
+                    
+                    # Conversion should still be called
+                    assert mock_convert.call_count == 2  # m4a and mp3
+                    
+                    assert result == "test_audio.mp3"
+
+    def test_convert_uploaded_file_compression_enabled(self, temp_dir, test_audio_file):
+        """Test convert_uploaded_file with compression explicitly enabled"""
+        filename = "test_audio.wav"
+        test_audio_file(filename)
+        
+        with patch('roundware.lib.convertaudio.compress_audio_file') as mock_compress:
+            with patch('roundware.lib.convertaudio.normalize_audio_file') as mock_normalize:
+                with patch('roundware.lib.convertaudio.convert_audio_file') as mock_convert:
+                    mock_convert.return_value = None
+                    
+                    result = convert_uploaded_file(filename, enable_compression=True)
+                    
+                    # Compression should be called
+                    mock_compress.assert_called_once()
+                    
+                    # Normalization should still be called
+                    mock_normalize.assert_called_once()
+                    
+                    # Conversion should still be called
+                    assert mock_convert.call_count == 2  # m4a and mp3
+                    
+                    assert result == "test_audio.mp3"
+
+    def test_convert_uploaded_file_default_parameter(self, temp_dir, test_audio_file):
+        """Test convert_uploaded_file with default parameter (uses settings)"""
+        filename = "test_audio.wav"
+        test_audio_file(filename)
+        
+        with patch('roundware.lib.convertaudio.compress_audio_file') as mock_compress:
+            with patch('roundware.lib.convertaudio.normalize_audio_file') as mock_normalize:
+                with patch('roundware.lib.convertaudio.convert_audio_file') as mock_convert:
+                    mock_convert.return_value = None
+                    
+                    # Test with settings.AUDIO_COMPRESSION_ENABLED = True
+                    with override_settings(AUDIO_COMPRESSION_ENABLED=True):
+                        result = convert_uploaded_file(filename)  # No compression parameter
+                        
+                        # Compression should be called (uses settings)
+                        mock_compress.assert_called_once()
+                        
+                        # Normalization should still be called
+                        mock_normalize.assert_called_once()
+                        
+                        assert result == "test_audio.mp3"
+
+    def test_speakers_api_compression_parameter_true(self, temp_dir):
+        """Test speakers API with audio_compression=true parameter"""
+        from roundware.lib.api import save_speaker_from_request
+        
+        # Create a mock request with audio_compression=true
+        mock_request = MagicMock()
+        mock_file = MagicMock()
+        mock_file.name = "test_audio.wav"
+        mock_file.file.read.return_value = b"fake audio content"
+        mock_request.FILES = {'file': mock_file}
+        mock_request.data = {'project': 1, 'audio_compression': True}
+        mock_request.get_host.return_value = 'localhost:8000'
+        
+        with patch('roundware.lib.api.convertaudio.convert_uploaded_file') as mock_convert:
+            mock_convert.return_value = "test_audio.mp3"
+            
+            result = save_speaker_from_request(mock_request)
+            
+            # Should call convert_uploaded_file with enable_compression=True
+            # The filename will include a timestamp, so we check the call args
+            call_args = mock_convert.call_args
+            assert call_args[0][0].startswith("speaker-project1-test_audio-")  # filename
+            assert call_args[0][1] is True  # enable_compression
+            
+            # Should return the expected URL
+            assert ".mp3" in result
+
+    def test_speakers_api_compression_parameter_false(self, temp_dir):
+        """Test speakers API with audio_compression=false parameter"""
+        from roundware.lib.api import save_speaker_from_request
+        
+        # Create a mock request with audio_compression=false
+        mock_request = MagicMock()
+        mock_file = MagicMock()
+        mock_file.name = "test_audio.wav"
+        mock_file.file.read.return_value = b"fake audio content"
+        mock_request.FILES = {'file': mock_file}
+        mock_request.data = {'project': 1, 'audio_compression': False}
+        mock_request.get_host.return_value = 'localhost:8000'
+        
+        with patch('roundware.lib.api.convertaudio.convert_uploaded_file') as mock_convert:
+            mock_convert.return_value = "test_audio.mp3"
+            
+            result = save_speaker_from_request(mock_request)
+            
+            # Should call convert_uploaded_file with enable_compression=False
+            # The filename will include a timestamp, so we check the call args
+            call_args = mock_convert.call_args
+            assert call_args[0][0].startswith("speaker-project1-test_audio-")  # filename
+            assert call_args[0][1] is False  # enable_compression
+            
+            # Should return the expected URL
+            assert ".mp3" in result
+
+    def test_speakers_api_compression_parameter_default(self, temp_dir):
+        """Test speakers API without audio_compression parameter (defaults to False)"""
+        from roundware.lib.api import save_speaker_from_request
+        
+        # Create a mock request without audio_compression parameter
+        mock_request = MagicMock()
+        mock_file = MagicMock()
+        mock_file.name = "test_audio.wav"
+        mock_file.file.read.return_value = b"fake audio content"
+        mock_request.FILES = {'file': mock_file}
+        mock_request.data = {'project': 1}  # No audio_compression parameter
+        mock_request.get_host.return_value = 'localhost:8000'
+        
+        with patch('roundware.lib.api.convertaudio.convert_uploaded_file') as mock_convert:
+            mock_convert.return_value = "test_audio.mp3"
+            
+            result = save_speaker_from_request(mock_request)
+            
+            # Should call convert_uploaded_file with enable_compression=False (default)
+            # The filename will include a timestamp, so we check the call args
+            call_args = mock_convert.call_args
+            assert call_args[0][0].startswith("speaker-project1-test_audio-")  # filename
+            assert call_args[0][1] is False  # enable_compression (default)
+            
+            # Should return the expected URL
+            assert ".mp3" in result
+
+    def test_speakers_api_compression_parameter_string_values(self, temp_dir):
+        """Test speakers API with string values for audio_compression parameter"""
+        from roundware.lib.api import save_speaker_from_request
+        
+        # Test with "true" string
+        mock_request = MagicMock()
+        mock_file = MagicMock()
+        mock_file.name = "test_audio.wav"
+        mock_file.file.read.return_value = b"fake audio content"
+        mock_request.FILES = {'file': mock_file}
+        mock_request.data = {'project': 1, 'audio_compression': 'true'}
+        mock_request.get_host.return_value = 'localhost:8000'
+        
+        with patch('roundware.lib.api.convertaudio.convert_uploaded_file') as mock_convert:
+            mock_convert.return_value = "test_audio.mp3"
+            
+            result = save_speaker_from_request(mock_request)
+            
+            # Should call convert_uploaded_file with enable_compression=True
+            # The filename will include a timestamp, so we check the call args
+            call_args = mock_convert.call_args
+            assert call_args[0][0].startswith("speaker-project1-test_audio-")  # filename
+            assert call_args[0][1] is True  # enable_compression (string "true" converted)
+            
+            # Should return the expected URL
+            assert ".mp3" in result
+
+    def test_admin_upload_compression_disabled(self, temp_dir):
+        """Test that admin uploads have compression disabled by default"""
+        from roundware.rw.file_utils import handle_speaker_audio_upload
+        
+        # Create a mock speaker and request
+        mock_speaker = MagicMock()
+        mock_speaker.project.id = 1
+        mock_speaker.code = 'admin_test'
+        
+        mock_uploaded_file = MagicMock()
+        mock_uploaded_file.name = 'admin_audio.wav'
+        mock_uploaded_file.chunks.return_value = [b'fake audio content']
+        
+        with patch('roundware.lib.convertaudio.convert_uploaded_file') as mock_convert:
+            mock_convert.return_value = "admin_audio.mp3"
+            
+            result = handle_speaker_audio_upload(mock_uploaded_file, mock_speaker)
+            
+            # Should call convert_uploaded_file with enable_compression=False
+            # The filename will include a timestamp, so we check the call args
+            call_args = mock_convert.call_args
+            if call_args and len(call_args[0]) >= 2:
+                assert call_args[0][0].startswith("speaker-project1-admin_test-")  # filename
+                assert call_args[0][1] is False  # enable_compression (admin default)
+            else:
+                # If called with keyword arguments, check those
+                assert mock_convert.call_args[1]['enable_compression'] is False
+            
+            # Should return the expected URI
+            assert "admin_audio.mp3" in result

roundware/api2/views.py

@@ -1274,6 +1274,19 @@ def retrieve(self, request, pk=None):
     def create(self, request):
         """
         POST api/2/speakers/ - Create a new Speaker
+        
+        Parameters:
+        - file: Audio file to upload (multipart/form-data)
+        - audio_compression: Boolean to enable/disable audio compression (default: false)
+        - project_id: Project ID
+        - code: Speaker code
+        - maxvolume: Maximum volume (0.0-1.0)
+        - minvolume: Minimum volume (0.0-1.0)
+        - uri: Audio URI (if not uploading file)
+        - backupuri: Backup audio URI
+        - shape: GeoJSON shape for speaker area
+        - attenuation_distance: Distance for audio attenuation
+        - activeyn: Whether speaker is active (boolean)
         """
         if "project_id" in request.data:
             request.data['project'] = request.data['project_id']

roundware/lib/api.py

@@ -773,8 +773,16 @@ def save_speaker_from_request(request):
 
     # Do I need to delete the original file after copying to rwmedia/?
 
+    # Check for audio_compression parameter in request data
+    # Default to False (disable compression) for better quality by default
+    enable_compression = request.data.get('audio_compression', False)
+    if isinstance(enable_compression, str):
+        enable_compression = enable_compression.lower() in ('true', '1', 'yes', 'on')
+    
+    logger.info("Audio compression setting: %s for file: %s", enable_compression, dest_filename)
+
     # Make sure speaker audio is available in both mp3 and m4a (for iOS) to be comprehensive
-    newfilename = convertaudio.convert_uploaded_file(dest_filename)
+    newfilename = convertaudio.convert_uploaded_file(dest_filename, enable_compression)
     if not newfilename:
         raise RoundException("File not converted successfully: " + newfilename)
 

roundware/lib/convertaudio.py

@@ -15,20 +15,34 @@
 
 # Converts the given file to both wav and mp3 and stores the files in the audio directory.
 # Handles files of various formats depending on the file extension.
-def convert_uploaded_file(filename):
+def convert_uploaded_file(filename, enable_compression=None):
+    """
+    Convert uploaded audio file with optional compression control.
+    
+    Args:
+        filename: Name of the file to convert
+        enable_compression: Boolean to override compression setting. 
+                          If None, uses settings.AUDIO_COMPRESSION_ENABLED
+    """
     (filename_prefix, filename_extension) = os.path.splitext(filename)
     upload_dir = settings.MEDIA_ROOT
     filepath = os.path.join(upload_dir, filename)
     if not os.path.exists(filepath):
         raise RoundException(
             "Uploaded file not found: " + filepath)
     else:
-        # Apply audio compression if enabled in settings (before normalization)
-        if getattr(settings, 'AUDIO_COMPRESSION_ENABLED', True):
+        # Determine if compression should be applied
+        if enable_compression is None:
+            compression_enabled = getattr(settings, 'AUDIO_COMPRESSION_ENABLED', True)
+        else:
+            compression_enabled = enable_compression
+        
+        # Apply audio compression if enabled (before normalization)
+        if compression_enabled:
             logger.info(f"Audio compression enabled - processing {filename}")
             compress_audio_file(upload_dir, filename_prefix, filename_extension)
         else:
-            logger.debug(f"Audio compression disabled - skipping {filename}")
+            logger.info(f"Audio compression disabled - skipping {filename}")
 
         # Normalize audio if enabled in settings (after compression)
         if getattr(settings, 'AUDIO_NORMALIZATION_ENABLED', True):

roundware/rw/admin_upload.py

@@ -73,9 +73,10 @@ def clean_audio_upload(self):
         saved_path = default_storage.save(file_path, uploaded_file)
 
         # Process the uploaded file (compression, normalization, format conversion)
+        # Admin uploads default to NO compression for better quality
         try:
             from roundware.lib.convertaudio import convert_uploaded_file
-            processed_filename = convert_uploaded_file(unique_filename)
+            processed_filename = convert_uploaded_file(unique_filename, enable_compression=False)
             # Update saved_path to the processed version (MP3)
             saved_path = os.path.join('speaker_audio', processed_filename)
         except Exception as e:

roundware/rw/file_utils.py

@@ -51,9 +51,10 @@ def handle_speaker_audio_upload(uploaded_file, speaker, request=None, project_id
             destination.write(chunk)
 
     # Process the uploaded file (compression, normalization, format conversion)
+    # Admin uploads default to NO compression for better quality
     try:
         from roundware.lib.convertaudio import convert_uploaded_file
-        processed_filename = convert_uploaded_file(filename)
+        processed_filename = convert_uploaded_file(filename, enable_compression=False)
         # Update filename to the processed version (MP3)
         filename = processed_filename
         file_path = os.path.join(settings.MEDIA_ROOT, filename)