Create app.py

app.py

@@ -0,0 +1,324 @@
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+import cv2
+import pyaudio
+import wave
+import imageio
+import av
+import moviepy.editor as mp
+import os
+import numpy as np
+from io import BytesIO
+
+# Initialize session state
+if 'file_history' not in st.session_state:
+    st.session_state['file_history'] = []
+if 'ping_code' not in st.session_state:
+    st.session_state['ping_code'] = ""
+if 'uploaded_files' not in st.session_state:
+    st.session_state['uploaded_files'] = []
+
+# Function to save to history
+def save_to_history(file_type, file_path):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    st.session_state['file_history'].append({
+        "Timestamp": timestamp,
+        "Type": file_type,
+        "Path": file_path
+    })
+
+# Sidebar configuration
+st.sidebar.header("📸 Configuration")
+library_choice = st.sidebar.selectbox(
+    "Select Library",
+    ["OpenCV", "PyAudio", "ImageIO", "PyAV", "MoviePy"]
+)
+resolution = st.sidebar.select_slider(
+    "Resolution",
+    options=["320x240", "640x480", "1280x720"],
+    value="640x480"
+)
+fps = st.sidebar.slider("FPS", 1, 60, 30)
+
+# DTMF-style ping code input
+st.sidebar.subheader("🔢 Device Ping Code")
+col1, col2, col3, col4 = st.sidebar.columns(4)
+with col1:
+    digit1 = st.selectbox("D1", [str(i) for i in range(10)], key="d1")
+with col2:
+    digit2 = st.selectbox("D2", [str(i) for i in range(10)], key="d2")
+with col3:
+    digit3 = st.selectbox("D3", [str(i) for i in range(10)], key="d3")
+with col4:
+    digit4 = st.selectbox("D4", [str(i) for i in range(10)], key="d4")
+ping_code = digit1 + digit2 + digit3 + digit4
+st.session_state['ping_code'] = ping_code
+st.sidebar.write(f"Ping Code: {ping_code}")
+
+# Main UI
+st.title("📸 Camera & Audio Capture Tool")
+
+# Outline with top 3 function examples
+st.header("📸 Top Five Python Libraries")
+
+# 1. OpenCV
+with st.expander("1. 📷 OpenCV"):
+    st.write("🎥 *Best Feature*: Real-time image processing and video capture.")
+    st.subheader("Top 3 Function Examples")
+    
+    st.write("1. `cv2.VideoCapture()` - Capture and display video")
+    if st.button("Run VideoCapture", key="opencv_1"):
+        cap = cv2.VideoCapture(0)
+        frame_placeholder = st.empty()
+        for _ in range(50):  # 50 frames
+            ret, frame = cap.read()
+            if ret:
+                frame_placeholder.image(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        cap.release()
+
+    st.write("2. `cv2.imwrite()` - Save processed image")
+    if st.button("Run imwrite", key="opencv_2"):
+        cap = cv2.VideoCapture(0)
+        ret, frame = cap.read()
+        if ret:
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # Convert to grayscale
+            file_path = f"opencv_gray_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+            cv2.imwrite(file_path, gray)
+            save_to_history("Image", file_path)
+            st.image(file_path, caption="Grayscale Image")
+        cap.release()
+
+    st.write("3. `cv2.Canny()` - Edge detection")
+    if st.button("Run Canny", key="opencv_3"):
+        cap = cv2.VideoCapture(0)
+        ret, frame = cap.read()
+        if ret:
+            edges = cv2.Canny(frame, 100, 200)
+            file_path = f"opencv_edges_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+            cv2.imwrite(file_path, edges)
+            save_to_history("Image", file_path)
+            st.image(file_path, caption="Edge Detection")
+        cap.release()
+
+# 2. PyAudio
+with st.expander("2. 🎙️ PyAudio"):
+    st.write("🔊 *Best Feature*: Low-level audio input/output control.")
+    st.subheader("Top 3 Function Examples")
+
+    st.write("1. `PyAudio.open()` - Record audio")
+    if st.button("Run Audio Record", key="pyaudio_1"):
+        p = pyaudio.PyAudio()
+        stream = p.open(format=pyaudio.paInt16, channels=1, rate=44100, input=True, frames_per_buffer=1024)
+        frames = [stream.read(1024) for _ in range(int(44100 / 1024 * 3))]  # 3 seconds
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+        file_path = f"pyaudio_rec_{datetime.now().strftime('%Y%m%d_%H%M%S')}.wav"
+        with wave.open(file_path, 'wb') as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(p.get_sample_size(pyaudio.paInt16))
+            wf.setframerate(44100)
+            wf.writeframes(b''.join(frames))
+        save_to_history("Audio", file_path)
+        st.audio(file_path)
+
+    st.write("2. `PyAudio.get_device_info_by_index()` - List audio devices")
+    if st.button("Run Device Info", key="pyaudio_2"):
+        p = pyaudio.PyAudio()
+        devices = [p.get_device_info_by_index(i) for i in range(p.get_device_count())]
+        st.write("Available Audio Devices:", devices)
+        p.terminate()
+
+    st.write("3. `stream.read()` - Real-time audio data")
+    if st.button("Run Stream Read", key="pyaudio_3"):
+        p = pyaudio.PyAudio()
+        stream = p.open(format=pyaudio.paInt16, channels=1, rate=44100, input=True, frames_per_buffer=1024)
+        data = stream.read(1024)
+        st.write("Sample audio data length:", len(data))
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+
+# 3. ImageIO
+with st.expander("3. 📹 ImageIO"):
+    st.write("🎥 *Best Feature*: Simple and efficient image/video I/O.")
+    st.subheader("Top 3 Function Examples")
+
+    st.write("1. `imageio.get_reader()` - Read webcam frames")
+    if st.button("Run get_reader", key="imageio_1"):
+        reader = imageio.get_reader('<video0>')
+        frame = reader.get_next_data()
+        file_path = f"imageio_frame_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        imageio.imwrite(file_path, frame)
+        save_to_history("Image", file_path)
+        st.image(file_path)
+
+    st.write("2. `imageio.imwrite()` - Save image with compression")
+    if st.button("Run imwrite", key="imageio_2"):
+        reader = imageio.get_reader('<video0>')
+        frame = reader.get_next_data()
+        file_path = f"imageio_comp_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        imageio.imwrite(file_path, frame, quality=85)  # Compressed
+        save_to_history("Image", file_path)
+        st.image(file_path, caption="Compressed Image")
+
+    st.write("3. `imageio.mimwrite()` - Create GIF")
+    if st.button("Run mimwrite", key="imageio_3"):
+        reader = imageio.get_reader('<video0>')
+        frames = [reader.get_next_data() for _ in range(10)]
+        file_path = f"imageio_gif_{datetime.now().strftime('%Y%m%d_%H%M%S')}.gif"
+        imageio.mimwrite(file_path, frames, fps=5)
+        save_to_history("GIF", file_path)
+        st.image(file_path, caption="GIF")
+
+# 4. PyAV
+with st.expander("4. 🎬 PyAV"):
+    st.write("🎥 *Best Feature*: Powerful FFmpeg-based AV processing.")
+    st.subheader("Top 3 Function Examples")
+
+    st.write("1. `av.open()` - Capture video")
+    if st.button("Run av.open", key="pyav_1"):
+        container = av.open('/dev/video0')
+        stream = container.streams.video[0]
+        file_path = f"pyav_vid_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        output = av.open(file_path, 'w')
+        out_stream = output.add_stream('h264', rate=30)
+        for i, frame in enumerate(container.decode(stream)):
+            if i > 30: break
+            out_frame = frame.reformat(out_stream.width, out_stream.height)
+            output.mux(out_stream.encode(out_frame))
+        output.close()
+        container.close()
+        save_to_history("Video", file_path)
+        st.video(file_path)
+
+    st.write("2. `container.decode()` - Extract audio")
+    if st.button("Run decode", key="pyav_2"):
+        container = av.open('/dev/video0', 'r', format='v4l2')
+        file_path = f"pyav_audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.wav"
+        output = av.open(file_path, 'w')
+        out_stream = output.add_stream('pcm_s16le', rate=44100)
+        for packet in container.demux():
+            for frame in packet.decode():
+                if frame.is_corrupt: continue
+                if hasattr(frame, 'to_ndarray'):
+                    output.mux(out_stream.encode(frame))
+            if os.path.getsize(file_path) > 100000: break  # Limit size
+        output.close()
+        container.close()
+        save_to_history("Audio", file_path)
+        st.audio(file_path)
+
+    st.write("3. `av.filter()` - Apply video filter")
+    if st.button("Run filter", key="pyav_3"):
+        container = av.open('/dev/video0')
+        stream = container.streams.video[0]
+        file_path = f"pyav_filter_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        output = av.open(file_path, 'w')
+        out_stream = output.add_stream('h264', rate=30)
+        graph = av.filter.Graph()
+        filt = graph.add("negate")  # Invert colors
+        for i, frame in enumerate(container.decode(stream)):
+            if i > 30: break
+            filt.push(frame)
+            out_frame = filt.pull()
+            output.mux(out_stream.encode(out_frame.reformat(out_stream.width, out_stream.height)))
+        output.close()
+        container.close()
+        save_to_history("Video", file_path)
+        st.video(file_path, caption="Negated Video")
+
+# 5. MoviePy
+with st.expander("5. 📼 MoviePy"):
+    st.write("🎥 *Best Feature*: High-level video editing.")
+    st.subheader("Top 3 Function Examples")
+
+    st.write("1. `ImageSequenceClip()` - Video from frames")
+    if st.button("Run ImageSequenceClip", key="moviepy_1"):
+        cap = cv2.VideoCapture(0)
+        frames = [cv2.cvtColor(cap.read()[1], cv2.COLOR_BGR2RGB) for _ in range(30)]
+        cap.release()
+        file_path = f"moviepy_seq_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        clip = mp.ImageSequenceClip(frames, fps=15)
+        clip.write_videofile(file_path)
+        save_to_history("Video", file_path)
+        st.video(file_path)
+
+    st.write("2. `VideoFileClip()` - Load and resize video")
+    if st.button("Run VideoFileClip", key="moviepy_2"):
+        cap = cv2.VideoCapture(0)
+        frames = [cv2.cvtColor(cap.read()[1], cv2.COLOR_BGR2RGB) for _ in range(30)]
+        cap.release()
+        temp_path = "temp.mp4"
+        mp.ImageSequenceClip(frames, fps=15).write_videofile(temp_path)
+        clip = mp.VideoFileClip(temp_path).resize((320, 240))
+        file_path = f"moviepy_resized_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        clip.write_videofile(file_path)
+        save_to_history("Video", file_path)
+        st.video(file_path, caption="Resized Video")
+
+    st.write("3. `concatenate_videoclips()` - Combine clips")
+    if st.button("Run concatenate", key="moviepy_3"):
+        cap = cv2.VideoCapture(0)
+        frames1 = [cv2.cvtColor(cap.read()[1], cv2.COLOR_BGR2RGB) for _ in range(15)]
+        frames2 = [cv2.cvtColor(cap.read()[1], cv2.COLOR_BGR2RGB) for _ in range(15)]
+        cap.release()
+        clip1 = mp.ImageSequenceClip(frames1, fps=15)
+        clip2 = mp.ImageSequenceClip(frames2, fps=15)
+        final_clip = mp.concatenate_videoclips([clip1, clip2])
+        file_path = f"moviepy_concat_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        final_clip.write_videofile(file_path)
+        save_to_history("Video", file_path)
+        st.video(file_path, caption="Concatenated Video")
+
+# Media Upload Section
+st.header("📂 Upload Media Files")
+uploaded_files = st.file_uploader("Upload Images, Audio, or Video", accept_multiple_files=True, type=['jpg', 'png', 'mp4', 'wav', 'mp3'])
+if uploaded_files:
+    for uploaded_file in uploaded_files:
+        file_type = uploaded_file.type.split('/')[0]
+        file_path = f"uploaded_{uploaded_file.name}"
+        with open(file_path, 'wb') as f:
+            f.write(uploaded_file.read())
+        st.session_state['uploaded_files'].append({
+            "Name": uploaded_file.name,
+            "Type": file_type,
+            "Path": file_path
+        })
+
+# Galleries and Players
+st.header("🖼️ Media Gallery")
+if st.session_state['uploaded_files']:
+    images = [f for f in st.session_state['uploaded_files'] if f['Type'] == 'image']
+    audios = [f for f in st.session_state['uploaded_files'] if f['Type'] == 'audio']
+    videos = [f for f in st.session_state['uploaded_files'] if f['Type'] == 'video']
+
+    if images:
+        st.subheader("Images")
+        cols = st.columns(3)
+        for i, img in enumerate(images):
+            with cols[i % 3]:
+                st.image(img['Path'], caption=img['Name'], use_column_width=True)
+
+    if audios:
+        st.subheader("Audio")
+        for audio in audios:
+            st.audio(audio['Path'], format=f"audio/{audio['Name'].split('.')[-1]}")
+            st.write(f"Name: {audio['Name']}")
+
+    if videos:
+        st.subheader("Videos")
+        for video in videos:
+            st.video(video['Path'])
+            st.write(f"Name: {video['Name']}")
+else:
+    st.write("No media uploaded yet.")
+
+# File History Display
+st.header("📜 File History")
+if st.session_state['file_history']:
+    df = pd.DataFrame(st.session_state['file_history'])
+    st.dataframe(df)
+else:
+    st.write("No files captured yet.")