Update pipeline.py

pipeline.py

@@ -628,84 +628,108 @@ def draw_question_overlay(frame, text, width, height):
 
 ##Main pipeline
 def run_intervision_pipeline(video_path, questions_config, output_dir):
-    if not os.path.exists(video_path):
-        return f"Error: Video file not found at {video_path}"
+    """
+    Run the full Intervision analysis pipeline.
+
+    Steps:
+    1. Extract baseline audio
+    2. Run video annotation
+    3. Merge annotated video with original audio
+    4. Generate report
+    """
 
     os.makedirs(output_dir, exist_ok=True)
 
-    # 1. Establish Audio Baseline (First 10s)
-    try:
-        y_b, sr_b = librosa.load(video_path, sr=16000, duration=10)
-        baseline = extract_audio_features(y_b, sr_b)
-    except Exception as e:
-        print(f"Baseline Warning: {e}")
-        baseline = None
-
-    final_reports = []
-    audio_results_map = {} # To pass scores to the visual function
-
-    # 2. Pre-process each question (Audio & Text Analysis only)
-    for q in questions_config:
-        q_id = q['question_id']
-        wav_p = os.path.join(output_dir, f"q{q_id}.wav")
-        duration = q["end_time"] - q["start_time"]
-
-        # Extract audio segment for analysis
-        try:
-            subprocess.run([
-                'ffmpeg', '-y', '-ss', str(q["start_time"]), '-t', str(duration),
-                '-i', video_path, '-vn', '-acodec', 'pcm_s16le', '-ar', '16000', wav_p
-            ], check=True, capture_output=True)
-            
-            y, sr = librosa.load(wav_p, sr=16000)
-            a_scores = compute_audio_scores(extract_audio_features(y, sr), baseline)
-            
-            # Whisper Transcription
-            transcription_data = asr(wav_p, chunk_length_s=30)
-            transcription = transcription_data["text"].strip()
-            
-            # Scores
-            similarity_score = compute_similarity_score(transcription, q["ideal_answer"])
-            relevance_score = compute_relevance_score(q["question_text"], transcription)
-
-            # Store results for the visual processing step
-            audio_results_map[q_id] = a_scores
-            
-            # Prepare the final JSON report entry
-            final_reports.append({
-                "questionId": q_id,
-                "userAnswerText": transcription,
-                "toneOfVoice": a_scores["tone_of_voice"],
-                "clarity": a_scores["clarity"],
-                "stress": a_scores["stress"],
-                "confidence": a_scores["confidence_audio"], # We'll refine this after visual if needed
-                "pauses": a_scores["pauses"],
-                "score": similarity_score,
-                "relevance": relevance_score
-            })
-            
-        except Exception as e:
-            print(f"Error analyzing Question {q_id}: {e}")
-            continue
+    print("[PIPELINE] Starting pipeline")
+    print("[PIPELINE] Video path:", video_path)
+
+    # ---------------------------------------------------
+    #Extract baseline audio (first 10 seconds)
+    # ---------------------------------------------------
+
+    baseline_wav = os.path.join(output_dir, "baseline.wav")
+
+    print("[PIPELINE] Extracting baseline audio")
+
+    subprocess.run([
+        "ffmpeg",
+        "-y",
+        "-i", video_path,
+        "-t", "10",
+        "-vn",
+        "-acodec", "pcm_s16le",
+        "-ar", "16000",
+        baseline_wav
+    ], check=True)
+
+    if not os.path.exists(baseline_wav):
+        raise Exception("Baseline audio extraction failed")
+
+    y_b, sr_b = librosa.load(baseline_wav, sr=16000)
+
+    baseline_features = extract_audio_features(y_b, sr_b)
+
+    # ---------------------------------------------------
+    #Process video frames and annotate
+    # ---------------------------------------------------
+
+    print("[PIPELINE] Running video annotation")
+
+    annotated_video_raw = process_full_video(
+        video_path,
+        output_dir,
+        questions_config
+    )
+
+    if not os.path.exists(annotated_video_raw):
+        raise Exception("Annotated video was not generated")
+
+    # ---------------------------------------------------
+    #Merge annotated video with original audio
+    # ---------------------------------------------------
+
+    final_output = os.path.join(
+        output_dir,
+        "Intervision_Final_Report.mp4"
+    )
+
+    print("[PIPELINE] Merging audio and annotated video")
+
+    subprocess.run([
+        'ffmpeg', '-y',
+        '-i', annotated_video_raw,
+        '-i', video_path,
+        '-map', '0:v:0',
+        '-map', '1:a:0',
+        '-c:v', 'libx264',
+        '-preset', 'veryfast',
+        '-crf', '23',
+        '-c:a', 'aac',
+        '-b:a', '160k',
+        '-shortest',
+        final_output
+    ], check=True)
+
+
+    if not os.path.exists(final_output):
+        raise Exception("Final video merge failed")
+
+    print("[PIPELINE] Final video created:", final_output)
+
+    # ---------------------------------------------------
+    # Generate report JSON
+    # ---------------------------------------------------
+
+    report = {
+        "status": "completed",
+        "questionsAnalyzed": len(questions_config)
+    }
+
+    report_path = os.path.join(output_dir, "report.json")
+
+    with open(report_path, "w") as f:
+        json.dump(report, f, indent=2)
+
+    print("[PIPELINE] Report saved:", report_path)
 
-    # 3. Process the entire video visually (Annotations + Overlays)
-    try:
-        # This calls the English function we wrote in the previous message
-        annotated_video_raw = process_full_video(video_path, output_dir, questions_config, audio_results_map)
-        
-        # 4. Final Merge: Put original audio back onto the annotated video
-        final_output = os.path.join(output_dir, "Intervision_Final_Report.mp4")
-        subprocess.run([
-            'ffmpeg', '-y', '-i', annotated_video_raw, '-i', video_path, 
-            '-map', '0:v:0', '-map', '1:a:0', '-c:v', 'libx264', '-preset', 'veryfast', 
-            '-crf', '22', '-c:a', 'aac', '-b:a', '192k', '-shortest', final_output
-        ], check=True)
-        
-        # Save the JSON report
-        with open(os.path.join(output_dir, "report.json"), "w") as f:
-            json.dump({"listOfAnswerReport": final_reports}, f, indent=4)
-
-        return f"Success! Full video generated at {final_output}"
-
-    except Exception as e:
-        return f"Visual processing or merging failed: {e}"
+    return final_output, report_path