YoutubeToPDF2.ipynb

import cv2
import subprocess
import numpy as np
from fpdf import FPDF
import tempfile
from google.colab import files
from skimage.metrics import structural_similarity as compare_ssim
from PIL import Image  # Import Pillow for image compression

youtube_url = "https://www.youtube.com/watch?v=zY2DMpCUfCg"  # Replace with your YouTube URL

def get_video_stream_url(youtube_url):
    """Retrieves the highest available resolution video stream URL (no audio) using yt-dlp."""
    try:
        result = subprocess.run(
            ["yt-dlp", "-f", "bestvideo[height<=?720]", "--get-url", youtube_url],
            capture_output=True,
            text=True,
            check=True,
        )
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        print(f"Error retrieving video URL: {e}")
        return None

def capture_frame(video_url, timestamp):
    """Captures a frame from the video at the given timestamp."""
    cap = cv2.VideoCapture(video_url)
    if not cap.isOpened():
        print("Error opening video stream.")
        return None

    cap.set(cv2.CAP_PROP_POS_MSEC, timestamp * 1000)
    success, frame = cap.read()
    cap.release()
    return frame if success else None

def compute_similarity(frame1, frame2):
    """Calculates the SSIM similarity score between two frames."""
    gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
    return compare_ssim(gray1, gray2, full=True)[0]  # Only return the score

def save_frames_as_pdf(frames, output_pdf):
    """Saves the frames into a PDF with reduced compression."""
    pdf = FPDF()
    for i in range(0, len(frames), 2):
        pdf.add_page()
        for j in range(2):
            if i + j < len(frames):
                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
                    cv2.imwrite(tmp.name, frames[i + j])

                    # Adjust image compression here
                    img = Image.open(tmp.name)
                    img.save(tmp.name, "PNG", compress_level=1)  # Lower value = less compression

                    pdf.image(tmp.name, x=10, y=10 + j * 140, w=190, h=130)
    pdf.output(output_pdf)

def main(youtube_url):
    video_url = get_video_stream_url(youtube_url)
    if video_url is None:
        return

    frames = []
    initial_timestamp = 3
    benchmark_frame = capture_frame(video_url, initial_timestamp)
    if benchmark_frame is None:
        print("Error capturing the initial frame.")
        return
    frames.append(benchmark_frame)

    timestamp = initial_timestamp + 5
    while True:
        current_frame = capture_frame(video_url, timestamp)
        if current_frame is None:
            break

        similarity_score = compute_similarity(current_frame, benchmark_frame)
        if similarity_score < 0.9:
            frames.append(current_frame)
            benchmark_frame = current_frame

        timestamp += 5

    output_pdf = "frames.pdf"
    save_frames_as_pdf(frames, output_pdf)
    print(f"PDF saved as {output_pdf}")
    files.download(output_pdf)

if __name__ == "__main__":
    main(youtube_url)