feat: voice recording

audio_processor.py

@@ -52,8 +52,24 @@ class AudioEmotionProcessor:
     def load_audio(self, filepath):
         """Load audio file and resample to target sample rate"""
         audio, sr = librosa.load(filepath, sr=self.sample_rate)
+        
+        # Normalize audio volume (boost quiet recordings)
+        audio = self.normalize_audio(audio)
+        
         return audio, sr
     
+    def normalize_audio(self, audio):
+        """Normalize audio to increase volume"""
+        # Get max absolute value
+        max_val = np.max(np.abs(audio))
+        
+        # Avoid division by zero
+        if max_val > 0:
+            # Normalize to 0.95 to prevent clipping
+            audio = audio / max_val * 0.95
+        
+        return audio
+    
     def get_audio_duration(self, audio, sr):
         """Get duration of audio in seconds"""
         return librosa.get_duration(y=audio, sr=sr)

streamlit_app.py

@@ -21,13 +21,13 @@ st.markdown("Analyze emotions from audio files with timeline visualization")
 FLASK_URL = os.getenv("FLASK_URL", "http://localhost:5000")
 
 # Create tabs
-tab1, tab2 = st.tabs(["📁 Test File Analysis", "🎙️ Audio Input Analysis"])
+tab1, tab2 = st.tabs(["📁 File Analysis", "🎙️ Audio Recording"])
 
 # ============================================
-# TAB 1: Test File Analysis
+# TAB 1: File Analysis
 # ============================================
 with tab1:
-    st.header("📁 Test File Analysis")
+    st.header("📁 File Analysis")
     st.markdown("Upload a pre-recorded audio file for sentiment analysis")
     
     # File selection option
@@ -300,63 +300,110 @@ with tab1:
 # TAB 2: Audio Input Analysis (Live Recording)
 # ============================================
 with tab2:
-    st.header("🎙️ Live Audio Input Analysis")
-    st.markdown("Record audio in real-time for sentiment analysis")
+    st.header("🎙️ Audio Recording Analysis")
+    st.markdown("Record audio from your microphone for real-time sentiment analysis")
     
-    # Recording controls
-    col1, col2, col3 = st.columns(3)
+    # Initialize session state for Tab 2
+    if 'tab2_results' not in st.session_state:
+        st.session_state.tab2_results = None
     
-    with col1:
-        record_btn = st.button("🔴 Start Recording", type="primary", width="stretch")
-    with col2:
-        stop_btn = st.button("⏹️ Stop Recording", width="stretch")
-    with col3:
-        analyze_record_btn = st.button("🔍 Analyze Recording", width="stretch")
+    # Audio recorder widget
+    audio_data = st.audio_input("Record your audio")
     
-    # Recording status
-    if record_btn:
-        st.warning("🔴 Recording... (This feature will be implemented)")
+    audio_filename = "recorded_audio.wav"
     
-    if stop_btn:
-        st.info("⏹️ Recording stopped")
+    if audio_data:
+        st.success("✅ Recording complete! You can now analyze it.")
     
-    # Audio input section
-    st.subheader("🎤 Audio Input Settings")
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        sample_rate = st.selectbox(
-            "Sample Rate",
-            options=[16000, 22050, 44100, 48000],
-            index=0,
-            help="Audio sample rate in Hz"
-        )
+    # Show audio player if available
+    if audio_data:
+        st.subheader("🎵 Audio Preview")
+        st.audio(audio_data)
     
-    with col2:
-        channels = st.selectbox(
-            "Channels",
-            options=["Mono", "Stereo"],
-            index=0,
-            help="Audio channel configuration"
-        )
+    # Analyze button
+    analyze_btn_tab2 = st.button(
+        "🔍 Analyze Audio",
+        type="primary",
+        width="stretch",
+        disabled=(audio_data is None),
+        key="analyze_tab2"
+    )
     
-    # Recorded audio preview (placeholder)
-    st.subheader("🎵 Recorded Audio Preview")
-    st.info("📝 No recording available yet. Click 'Start Recording' to begin.")
+    # Analysis process
+    if analyze_btn_tab2 and audio_data:
+        try:
+            # Prepare file for upload
+            if hasattr(audio_data, 'seek'):
+                audio_data.seek(0)
+            
+            files = {'file': (audio_filename, audio_data, 'audio/wav')}
+            
+            # Upload to Flask
+            with st.spinner("📤 Uploading audio..."):
+                upload_response = requests.post(
+                    f"{FLASK_URL}/upload",
+                    files=files
+                )
+            
+            if upload_response.status_code == 202:
+                job_data = upload_response.json()
+                job_id = job_data['job_id']
+                
+                # Poll for status
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                import time
+                max_attempts = 60
+                attempt = 0
+                
+                while attempt < max_attempts:
+                    status_response = requests.get(f"{FLASK_URL}/status/{job_id}")
+                    
+                    if status_response.status_code == 200:
+                        status_data = status_response.json()
+                        progress = status_data['progress']
+                        message = status_data['message']
+                        status = status_data['status']
+                        
+                        progress_bar.progress(progress / 100)
+                        status_text.text(f"⚙️ {message} ({progress}%)")
+                        
+                        if status == "completed":
+                            st.session_state.tab2_results = status_data['results']
+                            progress_bar.progress(100)
+                            status_text.empty()
+                            st.success("✅ Analysis Complete!")
+                            break
+                        
+                        elif status == "failed":
+                            error_msg = status_data.get('error', 'Unknown error')
+                            st.error(f"❌ Processing failed: {error_msg}")
+                            progress_bar.empty()
+                            status_text.empty()
+                            break
+                    
+                    time.sleep(5)
+                    attempt += 1
+                
+                if attempt >= max_attempts:
+                    st.error("⏱️ Processing timeout. Please try again.")
+            else:
+                st.error(f"❌ Upload failed: {upload_response.json().get('error', 'Unknown error')}")
+                
+        except requests.exceptions.ConnectionError:
+            st.error("❌ Could not connect to Flask server. Make sure it's running on port 5000!")
+        except Exception as e:
+            st.error(f"❌ An error occurred: {str(e)}")
     
-    # Analysis results (placeholder)
-    if analyze_record_btn:
-        with st.spinner("🔄 Analyzing recorded audio..."):
-            st.info("⚙️ Processing audio through Flask API...")
-        
-        st.success("✅ Analysis Complete!")
+    # Display results if available
+    if st.session_state.tab2_results:
+        results = st.session_state.tab2_results
         
-        # Results layout
         st.markdown("---")
         st.subheader("📊 Emotion Analysis Results")
         
-        # Emotion emoji mapping (supports all emotions)
+        # Emotion emoji mapping
         emotion_emoji_map = {
             'Happy': '😊',
             'Sad': '😢',
@@ -368,26 +415,23 @@ with tab2:
             'Calm': '😌'
         }
         
-        # Sample data for recorded audio
-        sample_data = pd.DataFrame({
-            'Time (s)': ['00:00', '00:08', '00:15', '00:22', '00:28'],
-            'Emotion': ['Neutral', 'Happy', 'Neutral', 'Sad', 'Neutral'],
-            'Confidence': [0.88, 0.85, 0.90, 0.72, 0.87]
-        })
+        # Convert timeline to DataFrame
+        timeline_data = results['timeline']
+        sample_data = pd.DataFrame(timeline_data)
+        sample_data.rename(columns={'time': 'Time (s)', 'emotion': 'Emotion', 'confidence': 'Confidence'}, inplace=True)
         
         # Add emoji column
         sample_data['Emoji'] = sample_data['Emotion'].map(emotion_emoji_map)
         
-        # Calculate metrics
-        total_duration = "00:30"
-        unique_emotions = sample_data['Emotion'].nunique()
-        dominant_emotion = sample_data['Emotion'].mode()[0]
-        dominant_emoji = emotion_emoji_map[dominant_emotion]
-        
         # Metrics
+        total_duration = results['duration']
+        unique_emotions = results['emotions_detected']
+        dominant_emotion = results['dominant_emotion']
+        dominant_emoji = emotion_emoji_map.get(dominant_emotion, '❓')
+        
         col1, col2, col3 = st.columns(3)
         with col1:
-            st.metric("Recording Duration", total_duration, help="Length of recording")
+            st.metric("Audio Duration", total_duration, help="Length of audio")
         with col2:
             st.metric("Emotions Detected", unique_emotions, help="Number of unique emotions")
         with col3:
@@ -401,9 +445,7 @@ with tab2:
         with col1:
             st.subheader("⏱️ Emotion Timeline")
             
-            # Bar chart with emojis
-            fig_timeline = go.Figure()
-            
+            # Color mapping
             colors = {
                 'Happy': '#FFD700',
                 'Sad': '#4169E1',
@@ -415,26 +457,28 @@ with tab2:
                 'Calm': '#87CEEB'
             }
             
-            for emotion in sample_data['Emotion'].unique():
-                emotion_data = sample_data[sample_data['Emotion'] == emotion]
-                fig_timeline.add_trace(go.Bar(
-                    x=emotion_data['Time (s)'],
-                    y=emotion_data['Confidence'],
-                    name=f"{emotion_emoji_map[emotion]} {emotion}",
-                    marker_color=colors[emotion],
-                    text=[emotion_emoji_map[emotion]] * len(emotion_data),
-                    textposition='outside',
-                    textfont=dict(size=20)
-                ))
+            # Create bar chart
+            bar_colors = [colors.get(emotion, '#808080') for emotion in sample_data['Emotion']]
+            bar_text = [emotion_emoji_map.get(emotion, '❓') for emotion in sample_data['Emotion']]
+            
+            fig_timeline = go.Figure()
+            fig_timeline.add_trace(go.Bar(
+                x=sample_data['Time (s)'],
+                y=sample_data['Confidence'],
+                marker_color=bar_colors,
+                text=bar_text,
+                textposition='outside',
+                textfont=dict(size=20),
+                hovertemplate='<b>%{x}</b><br>Confidence: %{y:.2%}<br><extra></extra>',
+                showlegend=False
+            ))
             
             fig_timeline.update_layout(
                 xaxis_title="Time",
                 yaxis_title="Confidence",
                 yaxis_range=[0, 1.1],
-                barmode='group',
                 height=400,
-                showlegend=True,
-                hovermode='x unified'
+                hovermode='x'
             )
             
             st.plotly_chart(fig_timeline, width="stretch")
@@ -442,13 +486,13 @@ with tab2:
         with col2:
             st.subheader("📊 Distribution")
             
-            # Pie chart for emotion distribution
+            # Pie chart
             emotion_counts = sample_data['Emotion'].value_counts()
             
             fig_pie = go.Figure(data=[go.Pie(
-                labels=[f"{emotion_emoji_map[e]} {e}" for e in emotion_counts.index],
+                labels=[f"{emotion_emoji_map.get(e, '❓')} {e}" for e in emotion_counts.index],
                 values=emotion_counts.values,
-                marker=dict(colors=[colors[e] for e in emotion_counts.index]),
+                marker=dict(colors=[colors.get(e, '#808080') for e in emotion_counts.index]),
                 textinfo='percent+label',
                 textfont=dict(size=12),
                 hole=0.3