Upload 8 files

.gitignore

@@ -0,0 +1,32 @@
+nodler/
+# Large binaries
+ffmpeg.exe
+ffprobe.exe
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+venv/
+ENV/
+env.bak/
+venv.bak/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rembrant Oyangoren Albeos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

STRUCTURE.md

@@ -0,0 +1,14 @@
+## Project Structure
+
+```text
+video-compressor/
+├── .gitignore
+├── app.py
+├── db.py
+├── ffmpeg.exe
+├── ffprobe.exe
+├── history.db
+├── LICENSE
+├── requirements.txt
+└── TECHSTACK.md
+```

TECHSTACK.md

@@ -0,0 +1,12 @@
+## Techstack
+
+Audit of **video-compressor** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| (no extension) | 2 | 1.3 |
+| Python (.py) | 2 | 10.3 |
+| Windows Executable (.exe) | 2 | 261,912.5 |
+| Database (.db) | 1 | 12.0 |
+| Plain Text (.txt) | 1 | 0.0 |
+| **Total** | **8** | **261,936.2** |

app.py

@@ -0,0 +1,227 @@
+import streamlit as st
+import tempfile
+import tempfile
+import os
+import time
+import ffmpeg
+import subprocess
+import platform
+from db import init_db, insert_record, get_records
+
+# Initialize Database
+init_db()
+
+st.set_page_config(page_title="Video Compressor", layout="wide")
+
+def get_video_info(file_path):
+    try:
+        probe = ffmpeg.probe(file_path)
+        video_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'video'), None)
+        audio_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'audio'), None)
+        
+        duration = float(probe['format']['duration'])
+        width = int(video_stream['width'])
+        height = int(video_stream['height'])
+        
+        # Audio bitrate defaults to 128k if not found or 0
+        audio_bitrate = 128000
+        if audio_stream and 'bit_rate' in audio_stream:
+             audio_bitrate = int(audio_stream['bit_rate'])
+        elif 'bit_rate' in probe['format']:
+             # fallback approximation
+             audio_bitrate = 128000
+             
+        return {
+            'duration': duration,
+            'width': width,
+            'height': height,
+            'audio_bitrate': audio_bitrate
+        }
+    except Exception as e:
+        st.error(f"Error probing video: {e}")
+        return None
+
+def compress_video_2pass(input_path, output_path, start_time, end_time, target_size_mb, resolution, fps, progress_bar):
+    info = get_video_info(input_path)
+    if not info:
+        return False
+        
+    duration = end_time - start_time
+    if duration <= 0:
+        st.error("Invalid trim times (End time must be greater than Start time).")
+        return False
+
+    # Calculate bitrates
+    # Target size in bits
+    target_size_bits = target_size_mb * 8388608  # MB to bits (1024 * 1024 * 8)
+    
+    # Audio bitrate in bits per second
+    audio_bitrate = info['audio_bitrate']
+    
+    # Required total bitrate (b/s)
+    total_bitrate = target_size_bits / duration
+    
+    # Required video bitrate (b/s)
+    video_bitrate = total_bitrate - audio_bitrate
+    
+    # Ensure a minimum video bitrate to avoid errors
+    if video_bitrate < 10000:
+        st.warning("Target size is too small for this duration. Video quality will be extremely poor or fail. Setting a minimum bitrate.")
+        video_bitrate = 10000
+
+    video_bitrate_k = int(video_bitrate / 1000)
+    audio_bitrate_k = int(audio_bitrate / 1000)
+
+    # Resolution scaling parameter
+    scale_param = ""
+    if resolution != "Original":
+        height = int(resolution.replace("p", ""))
+        scale_param = f"scale=-2:{height}"
+        
+    devnull = os.devnull
+
+    input_kwargs = {'ss': start_time, 'to': end_time}
+    
+    # Setup Streams
+    v_ext = ffmpeg.input(input_path, **input_kwargs)
+    a_ext = v_ext.audio
+    v = v_ext.video
+    
+    if scale_param:
+        v = v.filter('scale', -2, int(resolution.replace('p', '')))
+    
+    if fps and fps != "Original":
+        v = v.filter('fps', fps=int(fps))
+
+    # Pass 1
+    progress_bar.progress(20, text="Pass 1/2: Analyzing Video...")
+    passlog_base = os.path.join(tempfile.gettempdir(), f"ffmpeg2pass_{int(time.time())}")
+    try:
+        pass1_args = {
+            'c:v': 'libx264',
+            'b:v': f'{video_bitrate_k}k',
+            'pass': 1,
+            'passlogfile': passlog_base,
+            'f': 'mp4',
+            'y': None # overwrite
+        }
+        # In Windows, pass 1 log file must be handled properly, ffmpeg-python creates ffmpeg2pass-0.log in current dir
+        
+        # We construct the pass 1 output
+        out1 = ffmpeg.output(v, devnull, **pass1_args)
+        ffmpeg.run(out1, quiet=True, overwrite_output=True)
+    except ffmpeg.Error as e:
+        if e.stderr:
+            st.error(f"Pass 1 Error: {e.stderr.decode('utf8')}")
+        return False
+
+    # Pass 2
+    progress_bar.progress(60, text="Pass 2/2: Compressing Video...")
+    try:
+        pass2_args = {
+            'c:v': 'libx264',
+            'b:v': f'{video_bitrate_k}k',
+            'pass': 2,
+            'passlogfile': passlog_base,
+            'c:a': 'aac',
+            'b:a': f'{audio_bitrate_k}k',
+            'y': None # overwrite
+        }
+        out2 = ffmpeg.output(v, a_ext, output_path, **pass2_args)
+        ffmpeg.run(out2, quiet=True, overwrite_output=True)
+        
+    except ffmpeg.Error as e:
+        if e.stderr:
+            st.error(f"Pass 2 Error: {e.stderr.decode('utf8')}")
+        return False
+    finally:
+         # Clean up pass log files
+         for ext in ['-0.log', '-0.log.mbtree']:
+             logfile = f"{passlog_base}{ext}"
+             if os.path.exists(logfile):
+                 try:
+                     os.remove(logfile)
+                 except:
+                     pass
+
+    progress_bar.progress(100, text="Done!")
+    return True
+
+st.title("Video Compressor & Trimmer")
+st.markdown("Upload a video, trim it, set a target size, and this tool will use **2-pass encoding** to perfectly hit your target size (MB).")
+
+tab1, tab2 = st.tabs(["Compressor", "History"])
+
+with tab1:
+    uploaded_file = st.file_uploader("Upload Video", type=['mp4', 'mov', 'avi', 'mkv'])
+
+    if uploaded_file is not None:
+        # Save temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_input:
+            temp_input.write(uploaded_file.read())
+            temp_input_path = temp_input.name
+            
+        info = get_video_info(temp_input_path)
+        if info:
+            st.success(f"Video Loaded: {info['duration']:.2f} seconds | {info['width']}x{info['height']}")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                start_time = st.number_input("Start Time (seconds)", min_value=0.0, max_value=info['duration']-0.1, value=0.0, step=1.0)
+            with col2:
+                end_time = st.number_input("End Time (seconds)", min_value=0.1, max_value=info['duration'], value=info['duration'], step=1.0)
+                
+            col3, col4, col5 = st.columns(3)
+            with col3:
+                resolution = st.selectbox("Resolution", ["Original", "1080p", "720p", "480p", "360p"])
+            with col4:
+                fps = st.selectbox("FPS", ["Original", "60", "30", "24", "15"])
+            with col5:
+                target_size = st.number_input("Target Size (MB)", min_value=0.1, value=10.0, step=1.0)
+                
+            if st.button("Compress & Export"):
+                st.info("Ensure you have `ffmpeg` installed on your system.")
+                progress_bar = st.progress(0, text="Initializing...")
+                
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_output:
+                    temp_output_path = temp_output.name
+                    
+                start_perf = time.time()
+                success = compress_video_2pass(temp_input_path, temp_output_path, start_time, end_time, target_size, resolution, fps, progress_bar)
+                end_perf = time.time()
+                
+                if success:
+                    final_size_bytes = os.path.getsize(temp_output_path)
+                    final_size_mb = final_size_bytes / (1024 * 1024)
+                    duration_sec = end_time - start_time
+                    
+                    st.success(f"Compression Successful! Time taken: {end_perf - start_perf:.2f}s")
+                    st.metric("Final Size", f"{final_size_mb:.2f} MB")
+                    
+                    with open(temp_output_path, "rb") as file:
+                        btn = st.download_button(
+                            label="Download Compressed Video",
+                            data=file,
+                            file_name=f"compressed_{uploaded_file.name}",
+                            mime="video/mp4"
+                        )
+                    
+                    # Log to DB
+                    insert_record(uploaded_file.name, target_size, final_size_mb, duration_sec, resolution, fps if fps != "Original" else info.get('r_frame_rate', 0))
+                    
+                # cleanup output temp file after offering download
+                # os.remove(temp_output_path) -> actually we shouldn't remove immediately if download button needs it
+                # Streamlit's download button reads from memory here since we opened it.
+        
+        # Cleanup input temp file if we change files or stop
+        # (This is a simplistic approach, in production we'd use a more robust cleanup)
+
+with tab2:
+    st.header("Compression History")
+    records = get_records()
+    if not records:
+         st.write("No compression history found.")
+    else:
+         import pandas as pd
+         df = pd.DataFrame(records, columns=['ID', 'Original File', 'Target Size (MB)', 'Final Size (MB)', 'Duration (s)', 'Resolution', 'FPS', 'Timestamp'])
+         st.dataframe(df, hide_index=True)

db.py

@@ -0,0 +1,42 @@
+import sqlite3
+import os
+from datetime import datetime
+
+DB_PATH = os.path.join(os.path.dirname(__file__), 'history.db')
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS compression_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            original_filename TEXT NOT NULL,
+            target_size_mb REAL NOT NULL,
+            final_size_mb REAL NOT NULL,
+            duration_sec REAL NOT NULL,
+            resolution TEXT,
+            fps INTEGER,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def insert_record(original_filename, target_size_mb, final_size_mb, duration_sec, resolution, fps):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        INSERT INTO compression_history 
+        (original_filename, target_size_mb, final_size_mb, duration_sec, resolution, fps, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+    ''', (original_filename, target_size_mb, final_size_mb, duration_sec, resolution, fps, datetime.now()))
+    conn.commit()
+    conn.close()
+
+def get_records():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('SELECT * FROM compression_history ORDER BY timestamp DESC')
+    records = cursor.fetchall()
+    conn.close()
+    return records

requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+ffmpeg-python
+SQLAlchemy