Update src/audio/generator.py

src/audio/generator.py

@@ -76,11 +76,13 @@ def generate_translated_audio(srt_path, target_lang, video_duration=180):
             retry_count = 0
             while retry_count < MAX_RETRY_ATTEMPTS:
                 try:
-                    # For certain languages, use slower speed which might improve reliability
+                    # For certain languages, use slower speed
                     slow_option = target_lang in ["hi", "ja", "zh-CN", "ar"] 
                     tts = gTTS(text=text, lang=target_lang, slow=slow_option)
                     tts.save(str(audio_file))
                     
+                    logger.info(f"Generated TTS file size for chunk {i}: {audio_file.stat().st_size} bytes")
+                    
                     if audio_file.exists() and audio_file.stat().st_size > 0:
                         break
                     else:
@@ -89,9 +91,9 @@ def generate_translated_audio(srt_path, target_lang, video_duration=180):
                 except Exception as e:
                     retry_count += 1
                     logger.warning(f"TTS attempt {retry_count} failed for {target_lang}: {str(e)}")
-                    time.sleep(1)  # Wait before retrying
+                    time.sleep(1)
                     
-                    # If still failing after retries, try with shorter text
+                    # Fallback to shortened text
                     if retry_count == MAX_RETRY_ATTEMPTS - 1 and len(text) > 100:
                         logger.warning(f"Trying with shortened text for {target_lang}")
                         shortened_text = text[:100] + "..."
@@ -104,83 +106,77 @@ def generate_translated_audio(srt_path, target_lang, video_duration=180):
             else:
                 logger.warning(f"Failed to generate audio for subtitle {i}")
         
-        # Check if we generated any audio files
+        # Fallback if no audio generated
         if not audio_files:
-            logger.warning(f"No audio files were generated for {target_lang}")
-            # Create a silent audio file as fallback
+            logger.warning(f"No audio files generated for {target_lang}")
             silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
             create_silent_audio(video_duration, silent_audio)
             return silent_audio
-        
-        # Create a silent audio track as base
+
+        # Output configuration
+        output_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.mp3"
         silence_file = temp_dir / "silence.wav"
         create_silent_audio(video_duration, silence_file)
-        
-        # Create filter complex for audio mixing
-        filter_complex = []
-        input_count = 1  # Starting with 1 because 0 is the silence track
-        
-        # Start with silent track
-        filter_parts = ["[0:a]"]
-        
-        # Add each audio segment
-        for start_time, end_time, duration, audio_file in timings:
-            delay_ms = int(start_time * 1000)
-            filter_parts.append(f"[{input_count}:a]adelay={delay_ms}|{delay_ms}")
-            input_count += 1
-        
-        # Mix all audio tracks
-        filter_parts.append(f"amix=inputs={input_count}:dropout_transition=0:normalize=0[aout]")
-        filter_complex = ";".join(filter_parts)
-        
-        # Build the ffmpeg command
+
+        # Validate input files
+        for f in [silence_file, *audio_files]:
+            if not f.exists():
+                logger.error(f"Missing input file: {f}")
+                return create_silent_audio(video_duration, output_audio)
+
+        # Build FFmpeg command with volume boost and timing
         cmd = ['ffmpeg', '-y']
+        cmd += ['-i', str(silence_file)]
         
-        # Add silent base track
-        cmd.extend(['-i', str(silence_file)])
-        
-        # Add all audio chunks
+        # Add all audio chunks as inputs
         for audio_file in audio_files:
-            cmd.extend(['-i', str(audio_file)])
-        
-        # Add filter complex and output
-        output_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.mp3"
+            cmd += ['-i', str(audio_file)]
+
+        # Create filter chain for each audio chunk
+        filter_chains = []
+        for i, (start_time, _, _, _) in enumerate(timings):
+            delay_ms = int(start_time * 1000)
+            filter_chains.append(
+                f"[{i+1}:a]volume=12dB,adelay={delay_ms}|{delay_ms},apad=whole_dur={video_duration}[a{i}]"
+            )
 
-        output_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
-        cmd.extend([
+        # Mix all audio streams with normalization
+        mix_inputs = ''.join([f"[a{i}]" for i in range(len(timings))])
+        filter_complex = ";".join(filter_chains) + \
+                       f";{mix_inputs}amix=inputs={len(timings)}:duration=longest:normalize=0,volume=3dB[aout]"
+
+        cmd += [
             '-filter_complex', filter_complex,
             '-map', '[aout]',
-            output_audio
-        ])
-        
-        # Run the command
-        logger.info(f"Combining {len(audio_files)} audio segments")
-        logger.debug(f"Running command: {' '.join(cmd)}")
+            '-c:a', 'libmp3lame',  # Changed to MP3 codec
+            '-b:a', '192k',
+            str(output_audio)
+        ]
+
+        logger.debug(f"Running FFmpeg command: {' '.join(cmd)}")
+
+        # Execute audio mixing
         process = subprocess.run(cmd, capture_output=True, text=True)
         
         if process.returncode != 0:
-            logger.error(f"Audio combination failed: {process.stderr}")
-            # Create a fallback silent audio
+            logger.error(f"Audio mixing failed: {process.stderr}")
             silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
             create_silent_audio(video_duration, silent_audio)
-            output_audio = silent_audio
-        
-        # Clean up temporary files
+            return silent_audio
+
+        logger.info(f"Final audio file size: {output_audio.stat().st_size} bytes")
+
+        # Cleanup temporary files
         try:
             shutil.rmtree(temp_dir)
-            logger.debug(f"Cleaned up temporary directory: {temp_dir}")
+            logger.debug(f"Cleaned temporary directory: {temp_dir}")
         except Exception as e:
-            logger.warning(f"Failed to clean up temp directory: {str(e)}")
-        
-        logger.info(f"Successfully created translated audio: {output_audio}")
+            logger.warning(f"Temp cleanup failed: {str(e)}")
+
         return output_audio
+
     except Exception as e:
-        logger.error(f"Audio translation failed: {str(e)}", exc_info=True)
-        
-        # Create an emergency fallback silent audio
-        try:
-            silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
-            create_silent_audio(video_duration, silent_audio)
-            return silent_audio
-        except:
-            raise Exception(f"Audio translation failed: {str(e)}")
+        logger.error(f"Audio generation failed: {str(e)}", exc_info=True)
+        silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
+        create_silent_audio(video_duration, silent_audio)
+        return silent_audio