fix runtime dia audio is not generated issue

utils/tts_dia.py

@@ -114,108 +114,83 @@ def generate_speech(text: str, language: str = "zh") -> str:
         logger.info("Falling back to dummy TTS due to model loading error")
         from utils.tts_dummy import generate_speech as dummy_generate_speech
         return dummy_generate_speech(text, language)
+    
+    # Generate audio
+    logger.info("Starting audio generation with Dia model")
+    start_time = time.time()
+    
+    try:
+        with torch.inference_mode():
+            logger.info("Calling model.generate() with inference_mode")
+            output_audio_np = model.generate(
+                text,
+                max_tokens=None,  # Use default from model config
+                cfg_scale=3.0,
+                temperature=1.3,
+                top_p=0.95,
+                cfg_filter_top_k=35,
+                use_torch_compile=False,  # Keep False for stability
+                verbose=False
+            )
+            logger.info("Model.generate() completed")
+    except RuntimeError as rt_err:
+        logger.error(f"Runtime error during generation: {rt_err}")
+        if "CUDA out of memory" in str(rt_err):
+            logger.error("CUDA out of memory error - consider reducing batch size or model size")
+        # Fall back to dummy TTS
+        logger.info("Falling back to dummy TTS due to runtime error during generation")
+        from utils.tts_dummy import generate_speech as dummy_generate_speech
+        return dummy_generate_speech(text, language)
+    except Exception as gen_err:
+        logger.error(f"Error during audio generation: {gen_err}")
+        logger.error(f"Error type: {type(gen_err).__name__}")
+        # Fall back to dummy TTS
+        logger.info("Falling back to dummy TTS due to error during generation")
+        from utils.tts_dummy import generate_speech as dummy_generate_speech
+        return dummy_generate_speech(text, language)
+    
+    end_time = time.time()
+    generation_time = end_time - start_time
+    logger.info(f"Generation finished in {generation_time:.2f} seconds")
+    
+    # Process the output
+    if output_audio_np is not None:
+        logger.info(f"Generated audio array shape: {output_audio_np.shape}, dtype: {output_audio_np.dtype}")
+        logger.info(f"Audio stats - min: {output_audio_np.min():.4f}, max: {output_audio_np.max():.4f}, mean: {output_audio_np.mean():.4f}")
         
-        # Generate audio
-        logger.info("Starting audio generation with Dia model")
-        start_time = time.time()
+        # Apply a slight slowdown for better quality (0.94x speed)
+        speed_factor = 0.94
+        original_len = len(output_audio_np)
+        target_len = int(original_len / speed_factor)
         
+        logger.info(f"Applying speed adjustment factor: {speed_factor}")
+        if target_len != original_len and target_len > 0:
+            try:
+                x_original = np.arange(original_len)
+                x_resampled = np.linspace(0, original_len - 1, target_len)
+                output_audio_np = np.interp(x_resampled, x_original, output_audio_np)
+                logger.info(f"Resampled audio from {original_len} to {target_len} samples for {speed_factor:.2f}x speed")
+            except Exception as resample_err:
+                logger.error(f"Error during audio resampling: {resample_err}")
+                logger.warning("Using original audio without resampling")
+        
+        # Save the audio file
+        logger.info(f"Saving audio to file: {output_path}")
         try:
-            with torch.inference_mode():
-                logger.info("Calling model.generate() with inference_mode")
-                output_audio_np = model.generate(
-                    text,
-                    max_tokens=None,  # Use default from model config
-                    cfg_scale=3.0,
-                    temperature=1.3,
-                    top_p=0.95,
-                    cfg_filter_top_k=35,
-                    use_torch_compile=False,  # Keep False for stability
-                    verbose=False
-                )
-                logger.info("Model.generate() completed")
-        except RuntimeError as rt_err:
-            logger.error(f"Runtime error during generation: {rt_err}")
-            if "CUDA out of memory" in str(rt_err):
-                logger.error("CUDA out of memory error - consider reducing batch size or model size")
+            sf.write(output_path, output_audio_np, DEFAULT_SAMPLE_RATE)
+            logger.info(f"Audio successfully saved to {output_path}")
+        except Exception as save_err:
+            logger.error(f"Error saving audio file: {save_err}")
+            logger.error(f"Error type: {type(save_err).__name__}")
             # Fall back to dummy TTS
-            logger.info("Falling back to dummy TTS due to runtime error during generation")
-            from utils.tts_dummy import generate_speech as dummy_generate_speech
-            return dummy_generate_speech(text, language)
-        except Exception as gen_err:
-            logger.error(f"Error during audio generation: {gen_err}")
-            logger.error(f"Error type: {type(gen_err).__name__}")
-            # Fall back to dummy TTS
-            logger.info("Falling back to dummy TTS due to error during generation")
+            logger.info("Falling back to dummy TTS due to error saving audio file")
             from utils.tts_dummy import generate_speech as dummy_generate_speech
             return dummy_generate_speech(text, language)
         
-        end_time = time.time()
-        generation_time = end_time - start_time
-        logger.info(f"Generation finished in {generation_time:.2f} seconds")
-        
-        # Process the output
-        if output_audio_np is not None:
-            logger.info(f"Generated audio array shape: {output_audio_np.shape}, dtype: {output_audio_np.dtype}")
-            logger.info(f"Audio stats - min: {output_audio_np.min():.4f}, max: {output_audio_np.max():.4f}, mean: {output_audio_np.mean():.4f}")
-            
-            # Apply a slight slowdown for better quality (0.94x speed)
-            speed_factor = 0.94
-            original_len = len(output_audio_np)
-            target_len = int(original_len / speed_factor)
-            
-            logger.info(f"Applying speed adjustment factor: {speed_factor}")
-            if target_len != original_len and target_len > 0:
-                try:
-                    x_original = np.arange(original_len)
-                    x_resampled = np.linspace(0, original_len - 1, target_len)
-                    output_audio_np = np.interp(x_resampled, x_original, output_audio_np)
-                    logger.info(f"Resampled audio from {original_len} to {target_len} samples for {speed_factor:.2f}x speed")
-                except Exception as resample_err:
-                    logger.error(f"Error during audio resampling: {resample_err}")
-                    logger.warning("Using original audio without resampling")
-            
-            # Save the audio file
-            logger.info(f"Saving audio to file: {output_path}")
-            try:
-                sf.write(output_path, output_audio_np, DEFAULT_SAMPLE_RATE)
-                logger.info(f"Audio successfully saved to {output_path}")
-            except Exception as save_err:
-                logger.error(f"Error saving audio file: {save_err}")
-                logger.error(f"Error type: {type(save_err).__name__}")
-                # Fall back to dummy TTS
-                logger.info("Falling back to dummy TTS due to error saving audio file")
-                from utils.tts_dummy import generate_speech as dummy_generate_speech
-                return dummy_generate_speech(text, language)
-            
-            return output_path
-        else:
-            logger.warning("Generation produced no output (None returned from model)")
-            logger.warning("This may indicate a model configuration issue or empty input text")
-            dummy_path = f"{output_dir}/dummy_{timestamp}.wav"
-            logger.warning(f"Returning dummy audio path: {dummy_path}")
-            return dummy_path
-            
-    except Exception as e:
-        logger.error(f"TTS generation failed: {str(e)}", exc_info=True)
-        logger.error(f"Error type: {type(e).__name__}")
-        
-        # Log additional diagnostic information based on error type
-        if isinstance(e, ImportError):
-            logger.error(f"Import error - missing dependency: {e.__class__.__module__}.{e.__class__.__name__}")
-            logger.error("Check if all required packages are installed correctly")
-        elif isinstance(e, RuntimeError) and "CUDA" in str(e):
-            logger.error("CUDA-related runtime error - check GPU compatibility and memory")
-        elif isinstance(e, AttributeError):
-            logger.error(f"Attribute error - likely API incompatibility or incorrect module version")
-            if hasattr(e, '__traceback__'):
-                tb = e.__traceback__
-                while tb.tb_next:
-                    tb = tb.tb_next
-                logger.error(f"Error occurred in file: {tb.tb_frame.f_code.co_filename}, line {tb.tb_lineno}")
-        elif isinstance(e, FileNotFoundError):
-            logger.error(f"File not found - check if model files exist and are accessible")
-        
-        # Fall back to dummy TTS
-        logger.info("Falling back to dummy TTS due to unhandled exception")
-        from utils.tts_dummy import generate_speech as dummy_generate_speech
-        return dummy_generate_speech(text, language)
+        return output_path
+    else:
+        logger.warning("Generation produced no output (None returned from model)")
+        logger.warning("This may indicate a model configuration issue or empty input text")
+        dummy_path = f"{output_dir}/dummy_{timestamp}.wav"
+        logger.warning(f"Returning dummy audio path: {dummy_path}")
+        return dummy_path