Skip to main content
100%

from screen capture to video timelapse via CLI

✓ Published0🌍 Public
UUtopiah
Last edited Apr 17, 2020
Created on Apr 17, 2020

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.

AI-generated description

Similar vizzes

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
70% match
Loading thumbnail…

Screen Recording to GIF

This example demonstrates a command-line workflow for converting a QuickTime screen recording into an optimized GIF. It first uses ffmpeg to extract frames at 24 fps, then ImageMagick’s `convert` to build a palette from the first frame, remap all frames with `-remap` for color reduction, and finally gifsicle with `--optimize=3` to compress the output. A resize option via gifsicle shows how to scale the final image, while the code notes alternative tools like LICEcap and the trade-offs of uploading MOV files to Twitter.

11wheel
69% match
Loading thumbnail…

Screen Recording to GIF

This example shows how to convert a screen recording into an animated GIF using command-line tools. It first generates a color palette from the video with FFmpeg’s `palettegen` filter, then applies that palette with `paletteuse` to produce a high-quality GIF. The workflow also supports optional frame dropping via `fps` and cropping through FFmpeg’s `crop` filter. The code relies solely on FFmpeg and Gifsicle, with QuickTime Player used for the initial recording.

Mmbostock
69% 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
67% match
Loading thumbnail…

Gist 0591ab79900b3fe44d8b1560e3c35f40

This example demonstrates a workflow for converting animated WebP files into GIF format. The script uses `iwatch` to monitor a directory for new WebP files, then extracts each frame with `webpmux` and converts the frames to PNG using ImageMagick’s `convert`. Finally, it assembles the PNG sequence into a GIF with `ffmpeg`, while cleaning up temporary files. The code relies on the WebP tools API, ImageMagick, and FFmpeg’s glob pattern to handle the batch conversion, showing a practical pipeline for format transformation.

UUtopiah
62% 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
60% match
Loading thumbnail…

Gist b272bcf056720b0031d3

This R script generates a sequence of ten PNG images, each displaying an evolving line plot of randomly generated numeric data. At each step, it appends ten new random values to the existing vector and redraws the plot with an updated title. The code uses the base R `plot()`, `title()`, and `runif()` functions, saving each frame with `png()` and closing it with `dev.off()`. It demonstrates a simple iterative animation workflow, writing files to a local folder with sequentially numbered names.

RRCura
59% match
Loading thumbnail…

Speedup a video x2 using ffmpeg

This example demonstrates a shell script that doubles the playback speed of a video file using ffmpeg. It shows how the ffmpeg command-line tool manipulates video timing through the `setpts` filter, which adjusts presentation timestamps by multiplying them by 0.5. The script takes a filename as input, extracts the file extension, and constructs a new output filename with an `_x2` suffix. It uses bash scripting with `set -u` and `set -e` for error handling, and relies on standard shell utilities like `basename` and parameter expansion to process the filename.

CChristosT
57% match