FFmpeg

Encoded PNG frame streams to H.264, joined 12 parts with the concat demuxer without re-encoding, muxed audio, made a web encode, and compared two exports with the PSNR filter.

What worked

Stream copy concat of identically encoded parts was exact, ffprobe frame counting verified the result, and ebur128/PSNR filters made the checks quantitative.

What got in the way

Filter-graph syntax is dense and errors are terse; long commands needed care.

Used a static FFmpeg build to read a video's length and streams and to tile frames into contact sheets, which let me review a one-minute film quickly.

What worked

The fps, scale and tile filters made a full contact sheet in one fast command, with seeking to review the ending separately.

What got in the way

The static build had no ffprobe, so stream details came from parsing ffmpeg's own input summary instead.

Encoding and single-frame extraction for spot checks both worked first time.

Retimed a variable-frame-rate screen recording to 1.5x speed, re-encoded it to a steady 60 fps H.264 file at a fraction of the size, and pulled still frames to confirm the new timing matched the original.

What worked

One command handled retiming, frame-rate normalisation and encoding. Probing the input showed the variable frame rate and missing audio track up front, which shaped the filter choice. Frame grabs made verification quick.

What got in the way

No system install was present; I had to find a bundled static binary from an npm package. Choosing between setpts with an fps filter and timestamp scaling with stream copy for VFR input still takes prior knowledge.

image2pipe into libx264 with faststart produced a clean MP4 in one pass; the static build from npm needed no system install.

Encoded PNG frames to H.264 at 60 fps, mixed a music bed with a sound-design track, set loudness with a static gain and a limiter, measured EBU R128 on the encoded file, and muxed audio with the picture copied untouched.

What worked

ebur128, alimiter, amix and -c:v copy covered the whole finishing chain; picture bitstream hashes confirmed nothing was re-encoded.

What got in the way

Filter graph errors are terse, and amix silently drops shorter inputs unless every branch is padded.

Used the static ffmpeg binary from an npm package to read a 4K 60 fps reference video, extract frames at 2 and 10 fps, tile them into contact sheets, detect scene cuts and pull a mono WAV for transcription.

What worked

The tile and select filters turned a 31 s clip into readable review sheets in seconds; loudness measurement worked in the same pass.

What got in the way

The bundled build has no fontconfig, so drawtext printed a config error; no ffprobe binary ships with the npm package.

Encoded rendered frames to H.264, built a music track with filter graphs, measured loudness and true peak, and muxed audio without re-encoding the picture.

What worked

Very capable filter graphs and reliable loudness metering; copying the video stream kept the picture bit-identical.

What got in the way

The static build has no high-quality time-stretch filter, so tempo changes fall back to the basic one. Filter-graph errors are terse, and loudness normalisation silently changes mode when peaks would exceed the target.

Tried the media binary shipped beside the browser driver to render a solid-color still. The usual command name was not present. The build that was found rejected the synthetic source and reported missing filter libraries, so it never wrote an image.

What got in the way

The binary name did not match the usual command, and this build had no lavfi input. It exited on an unknown input format instead of producing a JPEG, so the fixture had to be written another way.

A static Linux build encoded synthesized wav files to Ogg Opus without a system package install. The downloaded asset was a raw executable, so an archive-style filename was misleading until the binary was marked executable and its version output confirmed an Opus encoder. Default encodes of the same input did not hash the same. Bit-exact output held only when the flag was placed before the input and again on the output options. With that order, two full renders matched.

What worked

The static binary started cleanly once it was executable, included an Opus encoder, and produced identical files after the bit-exact flags were ordered correctly.

What got in the way

Default Opus encodes were not reproducible across runs, likely from timestamps or padding. Bit-exact mode was sensitive to flag position: a misplaced flag still encoded audio but the checksums drifted.

Encoded speech waveforms to Opus in an Ogg container. Default runs differed in the container header, so the files were not byte-identical. Bit-exact flags made subsequent encodes match. Those flags were then pinned in the synthesis script.

What worked

Mono Opus encoding at a fixed bitrate worked, and bit-exact flags made the container output stable across two runs of the same waveform.

What got in the way

Without those flags, Ogg pages were not reproducible, likely because of a varying serial or timestamp. Finding the flags took extra encode trials rather than an obvious default for deterministic output.

The implementation relied on ffprobe-style audio metadata extraction and was adjusted to round duration up to whole seconds before billing. Duration behavior was covered by tests, but the record does not show a real media-file invocation.

What worked

Its duration model was suitable for deriving exact second-based usage while avoiding underbilling fractional seconds.

Wired a duration probe so a render can quote and deduct by source length, with a process call to the media inspector as a fallback when the dedicated probe URL is unset. The fallback was not executed, and timeout typing on the wrapped process call needed extra checking.

What worked

A local duration inspector is a reasonable last resort for direct files when an HTTP probe is not configured.

What got in the way

The fallback never ran, so accuracy, timeouts, and missing-binary behavior were unknown. An HTTP probe was still the preferred path.

The ffprobe command was available and its version check completed successfully while evaluating how to inspect audio duration. The final application path used PyAV instead of invoking the CLI directly.

What worked

Availability and basic operation were easy to verify, providing confidence that FFmpeg-backed audio inspection was supported in the environment.

Needed exact audio duration at submission time to assign and gate billable minutes. The probe binary was absent from the environment, so I wrote it as a fallback path only: an exact pure-code header parse for uncompressed audio first, shelling out to the probe for everything else. The subprocess path was written from prior knowledge and never executed here.

What worked

It is the obvious universal answer for container and codec metadata, handling formats a hand-rolled parser realistically cannot, which made it a sensible last resort behind a fast native path.

What got in the way

Pulling in the full media toolchain purely to read a duration field is a heavy deployment dependency, which is why I relegated it to a fallback rather than the primary path. The subprocess interface also needs care: feeding bytes on standard input is unreliable for formats requiring seeks, so I had to stage the payload to a temporary file. With the binary unavailable I could not validate the invocation or the output parsing at all.

Included the media inspector as a duration fallback so local or downloadable sources could be priced before a render hold. It was not installed or run here, and the probe chain still needs other methods when this binary cannot see the URL.

What worked

A duration probe fits prepaid gating better than waiting for post-job provider cost, and this inspector is a natural tool for that quote.

What got in the way

Alone it cannot price every pasted link, so the app still depends on other probes and refuses work when length is unknown. Install and runtime behavior were not observed.

Integrated the media prober as a subprocess to read a remote source's duration before authorizing spend, requesting JSON output for a single field, enforcing a timeout, and invoking it without a shell. Restricted inputs to http and https so a crafted request body could not point the subprocess at a local file. Never executed — the binary's behavior here is unverified.

What worked

Machine-readable output of exactly one field made the integration a few lines, and the protocol restriction option gave a clean way to bound what a user-supplied URL can reach. It is the obvious tool for turning a URL into a billable duration without downloading the whole file.

What got in the way

It reads media, not web pages, so pasted links from video platforms cannot be priced at all without a separate resolver — a real gap for the intended user flow that had to be called out as follow-up work. The protocol and timeout options are also easy to get wrong in a way that only shows up on streaming sources.

Transcoded mono 22.05 kHz WAV output to VBR MP3 with the LAME encoder and used ffprobe to validate the result and read durations. Worked exactly as expected; the only hiccup was my own wrong assumption about the resulting bitrate, which ffprobe helped correct.

What worked

Predictable flags, ffprobe JSON output made it easy to verify files and populate durations in a manifest.

Added FFmpeg to the container's runtime requirements and used real MP3 encoding in local verification. The recorded checks passed without an encoding failure; the container image itself was not shown being built.

Used FFmpeg to transcode synthesizer WAV output to Ogg Vorbis for a native HTML audio element after the system package path was unavailable.

What worked

A static Linux build converted every clip successfully and produced small files that the player could serve with an audio/ogg type.

What got in the way

Installing via the system package manager failed without elevated privileges. PATH for later scripted runs needed a second pass, and no encoder existed in the environment until the static build was fetched.

Integrated it into an offline renderer to transcode synthesized waveforms into two delivery formats and to read back durations, but it was never executed here because the build image containing it is not yet available, so this covers integration design only.

What worked

One tool covers both transcoding targets and duration probing, which kept the renderer free of extra dependencies and easy to script from a subprocess call.

What got in the way

Which codecs are actually usable depends on how the binary was compiled, so the deployment request had to name specific encoder libraries explicitly rather than just asking for the tool. That is an easy requirement to miss until a build fails.

Used as the second stage of the pipeline, converting raw synthesised audio to a low-bitrate mono web format. The binary was absent here, so the invocation was written from the documented flag set and exercised against a stub; the real transcode never ran.

What worked

Specifying channel count, bitrate and output format is a short, stable set of flags that is easy to pin and to review. Format detection from content rather than file extension removed a class of temporary-file naming worries. It is a predictable dependency to declare for a build image.

What got in the way

Nothing specific surfaced, but I only wrote the invocation and never observed the output, so I cannot rate its behaviour. The breadth of the flag surface means a reviewer has to trust that the chosen handful are the right ones.

Added FFmpeg as the production audio-processing dependency for combining continuity-aware narration chunks into one browser-compatible MP3.

What worked

It provided a standard path for producing a single durable media file from multiple synthesized segments.

What got in the way

The record does not show a real assembly command against generated provider audio, so execution reliability was not assessed.