Method save_audio_loop

web_demo/server/server.py:346–726

Async tasks for handling audio saving and inference

()

                log("info", "connection closed")

        async def save_audio_loop():
            """Async tasks for handling audio saving and inference"""
            nonlocal all_recorded_pcm, turn_counter, messages, audio_list, audio_buffer_list, audio_buffer_lock, all_generated_audio, reset_first_frame, reset_send_state, this_uuid, tts_offset, cur_audio_tokens, opus_reader, accumulate_tts_tokens
            
            current_generation = {
                'streamer': None,
                'accumulated_text': '',
                'generation_thread': None,
                'is_generating': False,
                'interrupt': False  
            }
            
            while True:
                if close:
                    return
                try:
                    signal_type, _ = await asyncio.wait_for(save_audio_queue.get(), timeout=0.1)
                    
                    if signal_type == 'pause':
                        # save audio and model inference
                        if all_recorded_pcm is not None and len(all_recorded_pcm) > 0:
                            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                            filename = f"{client_id}_turn{turn_counter}_input.wav"
                            filepath = os.path.join(self.output_dir, "input", filename)
                            
                            audio_duration = len(all_recorded_pcm) / self.sample_rate
                            
                            # resampling
                            if self.sample_rate != self.model_manager.target_sample_rate:
                                audio_tensor = torch.from_numpy(all_recorded_pcm).unsqueeze(0)
                                resampler = torchaudio.transforms.Resample(
                                    self.sample_rate, 
                                    self.model_manager.target_sample_rate
                                )
                                audio_tensor = resampler(audio_tensor)
                                audio_for_model = audio_tensor.squeeze(0).numpy()
                            else:
                                audio_for_model = all_recorded_pcm
                            
                            audio_tensor = torch.from_numpy(audio_for_model).unsqueeze(0)
                            torchaudio.save(filepath, audio_tensor, self.model_manager.target_sample_rate)
                            log("info", f"Saved audio to {filepath}, length: {audio_duration:.2f}s")
                            
                            # Prepare conversation messages
                            if len(messages) == 0:
                                messages = [{"role": "system", "content": session_system_prompt}]
                        
                            max_messages = 1 + MAX_HISTORY_TURNS * 2  # 1 for system prompt
                            if len(messages) >= max_messages:
                                messages_to_remove = len(messages) - max_messages + 2  
                                if messages_to_remove > 0:
                                    user_messages_removed = sum(1 for m in messages[1:1+messages_to_remove] if m['role'] == 'user')
                                    messages = [messages[0]] + messages[1+messages_to_remove:]
                                    audio_list = audio_list[user_messages_removed:]
                                    log("info", f"Trimmed history: removed {messages_to_remove} messages, {user_messages_removed} audio items")
                            
                            message_item = {"role": "user", "content": self.template}
                            audio_tokens = self.APAD_TOKEN * int(math.ceil(audio_duration * self.token_fps))