Update app.py

app.py

@@ -70,25 +70,10 @@ def diarize_audio(temp_file):
     # 返回 diarization 类对象
     return diarization
 
-# 将时间戳转换为秒
-def timestamp_to_seconds(timestamp):
-    try:
-        h, m, s = map(float, timestamp.split(':'))
-        return 3600 * h + 60 * m + s
-    except ValueError as e:
-        print(f"转换时间戳时出错: '{timestamp}'. 错误: {e}")
-        return None
-
-# 计算时间段的重叠部分（单位：秒）
-def calculate_overlap(start1, end1, start2, end2):
-    overlap_start = max(start1, start2)
-    overlap_end = min(end1, end2)
-    overlap_duration = max(0, overlap_end - overlap_start)
-    return overlap_duration
-
-# 获取所有说话人时间段（排除目标录音时间段）
-def get_all_speaker_segments(diarization_output, target_start_time, target_end_time, final_audio_length):
-    speaker_segments = {}
+# 获取目标录音所在时间范围最大的说话人及其时间段
+def get_most_matched_speaker_segments(diarization_output, target_start_time, target_end_time, final_audio_length):
+    # 用于存储说话人与目标音频重叠时间的字典
+    speaker_overlaps = {}
     
     # 使用 itertracks 获取每个说话人的信息
     for speech_turn in diarization_output.itertracks(yield_label=True):
@@ -96,19 +81,34 @@ def get_all_speaker_segments(diarization_output, target_start_time, target_end_t
         end_seconds = speech_turn[0].end
         label = speech_turn[1]
         
-        # 检查时间段是否与目标录音重叠
-        if start_seconds < target_end_time and end_seconds > target_start_time:
-            # 如果时间段与目标音频有重叠，调整结束时间
-            end_seconds = min(end_seconds, final_audio_length)
-        
-        # 存储说话人的时间段
-        if label not in speaker_segments:
-            speaker_segments[label] = []
+        # 计算目标音频与当前说话人时间段的重叠时间
+        overlap_start = max(start_seconds, target_start_time)
+        overlap_end = min(end_seconds, target_end_time)
+        overlap_duration = max(0, overlap_end - overlap_start)
         
-        # 添加处理后的时间段
-        speaker_segments[label].append((start_seconds, end_seconds))
-
-    return speaker_segments
+        # 如果有重叠，记录重叠时间
+        if overlap_duration > 0:
+            if label not in speaker_overlaps:
+                speaker_overlaps[label] = {
+                    'total_overlap': overlap_duration,
+                    'segments': []
+                }
+            else:
+                speaker_overlaps[label]['total_overlap'] += overlap_duration
+            
+            # 记录该说话人的原始时间段（排除目标音频时间段）
+            if start_seconds < target_start_time:
+                speaker_overlaps[label]['segments'].append((start_seconds, min(end_seconds, target_start_time)))
+            
+            if end_seconds > target_end_time:
+                speaker_overlaps[label]['segments'].append((max(start_seconds, target_end_time), end_seconds))
+    
+    # 找到重叠时间最长的说话人
+    if speaker_overlaps:
+        most_matched_speaker = max(speaker_overlaps, key=lambda k: speaker_overlaps[k]['total_overlap'])
+        return {most_matched_speaker: speaker_overlaps[most_matched_speaker]['segments']}
+    
+    return {}
 
 # 处理音频文件并返回输出
 def process_audio(target_audio, mixed_audio):
@@ -118,29 +118,38 @@ def process_audio(target_audio, mixed_audio):
     # 进行音频拼接并返回目标音频的起始和结束时间（作为字典）
     time_dict = combine_audio_with_time(target_audio, mixed_audio)
     
+    # 如果音频拼接出错，返回错误信息
+    if isinstance(time_dict, str):
+        return time_dict
+    
     # 执行说话人分离
     diarization_result = diarize_audio("final_output.wav")
     
     if isinstance(diarization_result, str) and diarization_result.startswith("错误"):
-        return diarization_result, None  # 出错时返回错误信息
+        return diarization_result  # 出错时返回错误信息
     else:
         # 获取拼接后的音频长度
         final_audio_length = len(AudioSegment.from_wav("final_output.wav")) / 1000  # 秒为单位
         
-        # 获取所有说话人的时间段
-        speaker_segments = get_all_speaker_segments(diarization_result, time_dict['start_time'], time_dict['end_time'], final_audio_length)
+        # 获取目标录音所在时间范围最大的说话人时间段
+        most_matched_speaker_segments = get_most_matched_speaker_segments(
+            diarization_result, 
+            time_dict['start_time'], 
+            time_dict['end_time'], 
+            final_audio_length
+        )
         
-        if speaker_segments:
-            # 返回所有说话人的时间段
-            return speaker_segments
+        if most_matched_speaker_segments:
+            # 返回目标录音所在时间范围最大的说话人的时间段（排除目标音频时间段）
+            return most_matched_speaker_segments
         else:
-            return "没有找到任何说话人的时间段。"
+            return "没有找到与目标录音重叠的说话人时间段。"
 
 # Gradio 接口
 with gr.Blocks() as demo:
     gr.Markdown("""
     # 🗣️ 音频拼接与说话人分类 🗣️
-    上传目标音频和混合音频，拼接并进行说话人分类。结果包括所有说话人的时间段（排除目标录音时间段）。
+    上传目标音频和混合音频，拼接并进行说话人分类。结果包括与目标录音重叠时间最长的说话人的时间段（排除目标录音时间段）。
     """)
     
     mixed_audio_input = gr.Audio(type="filepath", label="上传混合音频")
@@ -158,4 +167,4 @@ with gr.Blocks() as demo:
         outputs=[diarization_output]
     )
 
-demo.launch(share=True)
+demo.launch(share=True)