Update app.py

app.py

@@ -2,11 +2,12 @@ import gradio as gr
 import spaces
 import torch
 import dac
-import numpy as np
-from pydub import AudioSegment
-from audiotools import AudioSignal
 import io
-import soundfile as sf
+from audiotools import AudioSignal
+from pydub import AudioSegment
+
+# Ensure we're using CPU even if GPU is available
+torch.set_default_tensor_type(torch.FloatTensor)
 
 class DACApi:
     def __init__(self, model_type="44khz", model_bitrate="16kbps"):
@@ -15,106 +16,72 @@ class DACApi:
         self.model_path = dac.utils.download(model_type, model_bitrate)
         print("Loading DAC model...")
         self.model = dac.DAC.load(self.model_path)
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.model.to(self.device)
+        self.model.to('cpu')
 
-    @spaces.GPU
-    def encode_audio(self, input_file):
-        # Convert various audio formats to WAV if necessary
-        if not input_file.name.lower().endswith('.wav'):
-            print(f"Converting {input_file.name} to WAV...")
-            audio = AudioSegment.from_file(input_file.name)
-            input_wav = io.BytesIO()
-            audio.export(input_wav, format="wav")
-            input_wav.seek(0)
-        else:
-            input_wav = input_file
+    def encode_audio(self, audio):
+        # Convert audio to WAV
+        audio = AudioSegment.from_file(audio.name)
+        wav_io = io.BytesIO()
+        audio.export(wav_io, format="wav")
+        wav_io.seek(0)
 
         # Load audio signal
-        signal = AudioSignal(input_wav)
+        signal = AudioSignal(wav_io)
 
         # Compress audio
         print("Compressing audio...")
         compressed = self.model.compress(signal)
 
+        # Save compressed audio to BytesIO
         output = io.BytesIO()
         compressed.save(output)
         output.seek(0)
+        
         return output
 
-    @spaces.GPU
-    def decode_audio(self, input_file):
+    def decode_audio(self, compressed_file):
         # Load compressed audio
-        print("Loading compressed audio...")
-        compressed = dac.DACFile.load(input_file.name)
+        compressed = dac.DACFile.load(compressed_file)
 
         # Decompress audio
         print("Decompressing audio...")
         decompressed = self.model.decompress(compressed)
-
+        
+        # Save decompressed audio to BytesIO
         output = io.BytesIO()
         decompressed.write(output, format='wav')
         output.seek(0)
+        
         return output
 
-    @spaces.GPU
-    def stream_audio(self, input_file):
-        # Load compressed audio
-        print("Loading compressed audio...")
-        compressed = dac.DACFile.load(input_file.name)
-
-        # Decompress audio
-        print("Decompressing audio...")
-        decompressed = self.model.decompress(compressed)
-
-        audio_data = decompressed.audio_data.cpu().detach().numpy().squeeze().T
-        sample_rate = decompressed.sample_rate
-
-        return (sample_rate, audio_data)
-
 dac_api = DACApi()
 
+@spaces.CPU
 def encode(audio):
-    if isinstance(audio, torch.Tensor):
-        audio = audio.detach()
     compressed = dac_api.encode_audio(audio)
     return compressed
 
-def decode(audio):
-    if isinstance(audio, torch.Tensor):
-        audio = audio.detach()
-    decompressed = dac_api.decode_audio(audio)
+@spaces.CPU
+def decode(compressed_file):
+    decompressed = dac_api.decode_audio(compressed_file)
     return decompressed
 
-def stream(audio):
-    if isinstance(audio, torch.Tensor):
-        audio = audio.detach()
-    sample_rate, audio_data = dac_api.stream_audio(audio)
-    return (sample_rate, audio_data)
-
 # Gradio interface
 with gr.Blocks() as demo:
+    gr.Markdown("# Audio Compression with DAC")
     
     with gr.Tab("Encode"):
-        with gr.Row():
-            input_audio = gr.Audio(type="filepath", label="Input Audio")
-            output_file = gr.File(label="Compressed DAC File")
+        audio_input = gr.Audio(type="filepath", label="Input Audio")
         encode_button = gr.Button("Encode")
-        encode_button.click(encode, inputs=[input_audio], outputs=[output_file])
+        encoded_output = gr.File(label="Compressed Audio")
+        
+        encode_button.click(encode, inputs=audio_input, outputs=encoded_output)
     
     with gr.Tab("Decode"):
-        with gr.Row():
-            input_file = gr.File(label="Compressed DAC File")
-            output_audio = gr.Audio(label="Decompressed Audio")
+        compressed_input = gr.File(label="Compressed Audio")
         decode_button = gr.Button("Decode")
-        decode_button.click(decode, inputs=[input_file], outputs=[output_audio])
-    
-    with gr.Tab("Stream"):
-        with gr.Row():
-            stream_input = gr.File(label="Compressed DAC File")
-            stream_output = gr.Audio(label="Streamed Audio")
-        stream_button = gr.Button("Stream")
-        stream_button.click(stream, inputs=[stream_input], outputs=[stream_output])
+        decoded_output = gr.Audio(label="Decompressed Audio")
+        
+        decode_button.click(decode, inputs=compressed_input, outputs=decoded_output)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()