Skip to main content
100%

Video loss measurement (Generate by Kiro (kiro.dev))

✓ Published0🌍 Public
VVioletVivirand
Last edited Dec 23, 2025
Created on Dec 22, 2025

This example compares video quality loss between a source clip and two transcoded outputs (H.264 and H.265) by calculating PSNR and SSIM metrics for matched frames. It demonstrates how to align timecodes using FFmpeg's `setpts=PTS-STARTPTS` filter and then applies the `psnr` and `ssim` lavfi filters to compute per-frame scores, with a note that PSNR above 40 and SSIM above 0.8 indicate acceptable quality. The visualization shows the numeric metric results directly from the FFmpeg console output, highlighting the trade-offs between codec presets.

AI-generated description

Similar vizzes

Loading thumbnail…

VideoIO duration issue

This visualization demonstrates a duration mismatch issue in VideoIO by comparing video playback time against the number of frames processed. The code, authored by Wikunia and available as a gist, uses Julia's FFMPEG bindings to render a simple animated scene. It tracks and plots the elapsed time versus the expected frame-based duration, revealing a discrepancy where the reported playback duration does not match the actual time taken to process frames. The visualization highlights the timing bug through a line chart or similar plot, making the drift between real elapsed time and the video's internal clock immediately apparent.

WWikunia
55% match
Loading thumbnail…

Gist ad39e20ce7004353970bc6a1d163e248

This example shows a shell script that automatically converts a video file into a Twitter-compatible GIF by iteratively adjusting the output size. It first attempts a direct conversion with ffmpeg, then repeatedly re-encodes while halving or scaling the width until the resulting GIF falls between 10 and 15 megabytes. The script uses ffmpeg’s filter_complex with palettegen and paletteuse to generate a optimized color palette, and employs shell arithmetic and file-size checks to converge on the target. The process relies solely on command-line tools and standard Unix utilities, with no external JavaScript or visualization libraries involved.

UUtopiah
53% match
Loading thumbnail…

Twitter video handbrake settings

This visualization shows the exact encoding settings used in a HandBrake preset named “Twitter,” displaying the video and audio parameters as a structured plist. It maps the key-value pairs from the XML Property List file, including H.264 video encoding, 128 kbps AAC audio, 1280×720 resolution at 30 fps, and specific x264 options like the “fast” preset and “fastdecode” tune. The code parses the plist using Apple’s PropertyList API and renders the hierarchical dictionary as an interactive tree diagram with collapsible nodes.

MMattieTK
50% match
Loading thumbnail…

from screen capture to video timelapse via CLI

This example shows how a sequence of screen captures can be transformed into a playable video timelapse using command-line tools. The process starts with `scrot`, invoked via `watch -n 10`, to take screenshots every 10 seconds. A bash loop then renames the captured PNG files sequentially to `img%03d.png` format, ensuring proper ordering. Finally, `ffmpeg` assembles these frames into an MP4 video at 24 frames per second, scaling the output to 720 pixels wide. The code relies entirely on shell scripting, `scrot`, and `ffmpeg`, with no JavaScript or visualization libraries involved.

UUtopiah
50% match
Loading thumbnail…

Gist 57367d54143770b7c1d534cbfe002cd9

This example shows a Python script that combines multiple video clips into a single montage, resizing each to a fixed 460×720 resolution and concatenating them in sequence. The code uses MoviePy’s `VideoFileClip`, `concatenate_videoclips`, and `write_videofile` functions, along with its `vfx` module for potential filters. It saves the final output with a timestamped filename and writes it as an MP4 using the H.264 codec. The rendering approach relies on MoviePy’s FFmpeg backend, processing clips in sequential order without additional data sources.

CConorAspell
49% match
Loading thumbnail…

Gist f760b119be511c3b97e0f496b4dc1e1c

This example demonstrates a custom lossless image compression algorithm that encodes 16x16 pixel art using Sharp for image processing and node-base91 for encoding. It converts between 4-bit and 8-bit color formats to preserve the original artistic intent, as seen with the reference star and zero images. The code includes functions for converting RGB values to and from short hex codes, and encodes image data through Sharp's WebP lossless format before base91 encoding. The visualization shows compression results as encoded strings, verifying that the algorithm successfully reproduces the original images through lossless decoding.

SSohojoe
49% match
Loading thumbnail…

Bash script to process frames and convert then to a video format with ffmpeg

This example demonstrates how to assemble a sequence of numbered JPEG frames into a single video file. It relies on the Bash script to orchestrate the conversion, calling ffmpeg with a specified framerate of 30 frames per second. The command uses the libx264 codec with high profile settings, a constant rate factor of 18, and the yuv420p pixel format to ensure broad compatibility. The input pattern `path_to_file_%04d.jpeg` indicates that frames are named with four-digit zero-padded numbers, which ffmpeg then reads sequentially to produce the final `output.mp4`.

LLuisSevillano
49% match
Loading thumbnail…

Histogramme des pépites

This example visualizes a dataset of YouTube videos rated across multiple emotional and quality dimensions by four reviewers. It uses D3.js v4 with an SVG rendering to display the data as a histogram. The chart focuses on the distribution of total scores ("Note") for each video, highlighting the contrast between those labeled "pépite" (gem) and those not. The visualization is built from a CSV file containing ratings for categories like "Réflexion", "Amusement", "So deep", and negative feedback indicators, with each bar aggregated by video and annotated by author.

FFlazyy
48% match