Media, Broadcast & Production

Convert shutter angle to shutter speed at any frame rate — the 180° rule and its exceptions, for cinema cameras that think in degrees.

Check whether your shutter speed will band under 50 Hz or 60 Hz mains lighting, and get the flicker-safe shutter speeds for your region.

How long will a V-mount or NP-F battery power your rig? Watt-hours ÷ camera draw → runtime, plus how many batteries a shoot day needs.

Throw ratio × image width = projector distance. Find where to place the projector for your screen size, in metres and feet.

Is the projector bright enough for your screen and room? Lumens ÷ screen area × gain → foot-lamberts, checked against cinema and conference targets.

Turn a screen diagonal into real width and height for any aspect ratio — the dimensions a 100-, 120- or 150-inch screen actually occupies on your wall.

Match an LED wall's pixel pitch to your audience distance — the minimum and 'retina' distances where pixels disappear, for P1.9 to P10 panels.

Wall size ÷ pixel pitch = the actual resolution your LED wall delivers — and whether it can show HD or 4K content 1:1.

Distance ÷ speed of sound = the milliseconds of delay your fill or delay-tower speakers need, temperature-corrected, with the Haas offset explained.

What size amp for your speakers? Apply the pro-audio headroom rule to a speaker's continuous rating and get the recommended amplifier power range.

Estimate monthly Twitch income from subs, your revenue split and bits — the realistic math behind 'how much do streamers actually make'.

Price your podcast ads the way agencies do: downloads per episode × CPM × ad slots — per-episode and monthly sponsorship value.

Quote a voice-over job from the script's word count: finished minutes at your read speed, priced per finished minute or per word.

Estimate cloud encoding cost for a VOD library: source minutes × ABR ladder rungs × per-minute price — before the invoice surprises you.

What does serving your video library cost? Views × watch time × bitrate → monthly egress GB and the CDN bill at your per-GB rate.

How often must you re-jam? Clock accuracy in ppm × shoot hours → timecode drift in milliseconds and frames between camera and recorder.

Estimate streaming income from a stream count and a chosen platform's typical per-stream payout — Spotify, Apple Music, YouTube, Tidal and more.

Split a royalty payment among up to four collaborators by percentage and see each person's share — the fast way to settle a song's income.

Calculate US statutory mechanical royalties for physical/download sales using the 9.1¢ (≤5 min) or 1.75¢-per-minute rate.

Work out how much revenue (or how many streams) it takes to recoup a label or distributor advance at your royalty rate.

Split songwriting income into writer's share and publisher's share, and divide the writer's share among co-writers — the standard 50/50 publishing model.

Ballpark a sync licensing fee from the usage type, media and term — for placing music in film, TV, ads and games.

Convert producer 'points' into a percentage and dollar royalty from record sales/streams income — the standard producer-payment model.

See where a stream's money goes — gross payout, distributor cut, and your net per stream and per 1,000 streams.

Create a song split sheet — collaborator, role, writer % and master % — the document that prevents royalty disputes. Saved in your browser, export CSV.

Track your music's sync placements — title, licensee, media, fee, term and status — so you know what's licensed where and when terms expire. CSV export.

Log where each piece of music is used across a production — cue, track, usage type and duration — the source data for a PRO cue sheet. CSV export.

Get a recommended live-stream video bitrate for your resolution and frame rate, using a bits-per-pixel target tuned for H.264 streaming.

Get Twitch-safe encoder settings — bitrate, keyframe interval and resolution guidance — within Twitch's 6,000 kbit/s recommended ceiling.

Get YouTube's recommended live-stream bitrate range for your resolution and frame rate — YouTube allows much higher bitrates than Twitch.

Check whether your internet upload speed can safely sustain a stream bitrate — with the safety margin live streaming needs.

Estimate the risk of dropped frames from your stream bitrate versus available bandwidth and connection stability.

Convert between keyframe interval in seconds and GOP size in frames at your frame rate — and confirm the 2-second value platforms require.

Build a sensible ABR rendition ladder for a source resolution — the rungs (resolution + bitrate) a transcoder should produce for smooth adaptive streaming.

Split a total stream bitrate cap into video and audio so you stay under the platform limit with clean audio.

Calculate how much data a live stream consumes per hour (uploading) or per viewer-hour (watching) at a given bitrate.

For self-hosted RTMP/HLS: estimate the total egress bandwidth and monthly data your server needs for a given bitrate and concurrent-viewer count.

Understand the x264 preset vs CPU trade-off — how much quality (or bitrate saving) a slower preset buys, and whether your CPU can keep up live.

Catalog your video assets — clip, type, version, status, tags and storage location — in a searchable, browser-saved library you can export to CSV.

Organise your audio samples and loops — name, BPM, key, category and tags — into a fast personal library, saved in your browser with CSV export.

Keep brand assets — logos, fonts, colours, templates — with version, format and approved-usage notes in one place. Browser-saved, CSV export.

Track licensed stock clips, music and images — source, license type, cost and where they're used — so you never re-use a clip outside its license. CSV export.

Track usage rights and their expiry — asset, rights type, territory and end date — so you pull or renew content before the licence lapses. Browser-saved CSV.

Run review-and-approval on deliverables — asset, reviewer, round, status and notes — so feedback and sign-off are tracked in one place. CSV export, local.

Track the fonts a project uses and their licences — foundry, license type, seats and embedding rights — to stay compliant across web, app and broadcast. CSV export.

Version-track 3D assets — model, stage (modeling/rig/texture/final), version, artist and status — so the pipeline always knows the latest approved file. CSV export.

Map proxies to their masters and track which versions are conformed — so your offline edit always relinks to the correct online media. CSV export, browser-saved.

A free, full-screen online teleprompter — paste your script, set the speed and font, and read straight down the lens. Mirror mode for beam-splitter glass; nothing is uploaded.

A teleprompter tuned for YouTube creators — comfortable default pace, big readable text and a reading-time estimate so you can hit your target video length.

Run your webinar or live-stream script with an on-screen elapsed timer, so you stay on pace and on time while presenting to camera or screen-share.

A teleprompter with mirror mode on by default — the horizontally-flipped text a beam-splitter glass reflects back the right way round for the presenter.

A teleprompter calibrated in words-per-minute with a live reading-time estimate — rehearse your speech to an exact pace and duration.

Rehearse and deliver a presentation or keynote with a clean full-screen prompter and a timer — ideal for practising to length before the room.

Read to camera at broadcast news pace with a steady, professional scroll — a newsroom-style prompter for presenters and reporters.

A two-language teleprompter — put each language on a line separated by a pipe, and read both in sync. Ideal for bilingual events, dubbing and ceremonies.

Estimate Blender (Cycles/Eevee) render time and farm cost from frame count, minutes-per-frame, node count and node-hour rate.

Estimate Autodesk Maya + Arnold render time and cost — Arnold's per-core licensing and sampling make per-frame time the key input.

Estimate SideFX Houdini render or simulation farm cost — useful for caching heavy FX sims as well as Karma/Mantra renders.

Estimate Cinema 4D + Redshift GPU render time and cost — Redshift is GPU-based, so node-hour rates reflect GPU instances.

Estimate Unreal Engine 5 Movie Render Queue time and cost — real-time engine, but path-traced/high-sample MRQ frames can still be minutes each.

Compare the cost of a render job on a cloud farm versus your own machines (including electricity) to decide where to render.

Calculate the electricity cost (and heat) of a render job on your own machines from power draw, hours and your energy price.

Find the break-even point between buying a render node and renting cloud capacity, based on your monthly render hours.

Plan a project's total render spend across multiple shots with different frame counts and per-frame times at one farm rate.

Estimate the GPU VRAM a render needs from texture, geometry and frame-buffer memory — so a scene doesn't fall back to slow out-of-core rendering.

See how much render time AI denoising saves by letting you cut samples — the single biggest lever on path-traced render cost.

Track render jobs across a small farm — shot, frames, status, priority and assigned node — and export CSV. A lightweight queue board saved in your browser.

Convert a global DMX channel number to its universe and address-within-universe (1–512), and see the start address for patching.

How many DMX universes do you need? Enter fixture count and channels per fixture to get total channels and universes required.

Patch fixtures back-to-back: enter start address, channels per fixture and count to get every fixture's start address and the next free channel.

Check how many fixtures fit on a dimmer or circuit: enter fixture wattage, count and circuit rating to get load, current and the 80% safe limit.

Balance a lighting rig across three phases: enter total load and see per-phase current and the imbalance to even out.

Estimate voltage drop on a long power run from cable cross-section, length and current — so distant fixtures don't dim or colour-shift.

From a fixture's beam angle and throw distance, get the beam diameter at the target — for hanging and focusing fixtures precisely.

Compute illuminance (lux) at the stage from a fixture's intensity and throw using the inverse-square law — and how it changes if you move the fixture.

Work out the mired shift (and the CTB/CTO gel) needed to convert one color temperature to another — match tungsten to daylight and back.

See how much light output you lose through a color gel (and stacked gels) from each gel's transmission percentage.

Check whether a DMX512 cable run is within spec and how many fixtures/length before you need a splitter or terminator.

Build and save a DMX patch sheet — fixture, type, mode, universe, start address and position — and export it as CSV for the console and crew. Saved in your browser.

Plan a show's cue stack — cue number, label, fade time and follow — and export CSV to load into or check against the console. Saved locally.

Track your lighting stock — fixture, quantity, mode, weight and condition — for prep, rental and rigging weight planning. CSV export, saved in your browser.

Build a Foley spotting cue sheet — timecode, action, prop and surface per cue — and export it as CSV for the Foley stage. Saves in your browser.

Manage ADR (looping) cues — character, actor, line, reason and take status — and export a session-ready CSV. Saves locally in your browser.

Spot every sound effect — timecode, scene, effect, category and source library — for the sound editor, with CSV export. Client-side.

Build a broadcast music cue sheet — cue number, title, composer, publisher, usage type and duration — in the format PROs (ASCAP/BMI/PRS) need for royalty reporting. Exports CSV.

Log mix revision notes against timecode — reel, note, type and resolution status — so nothing from the review session is lost. CSV export, saved locally.

Track dialogue-editing tasks — timecode, character, issue and fix — across a programme so every line problem is logged and resolved. Client-side CSV.

Run a combined spotting session — log every department's note (music, dialogue, FX, Foley) against timecode in one shared list, then export CSV.

Track cut/version revisions on a project — version, date, change summary, owner and status — so everyone knows which cut is current. CSV export, local only.

Plan loop-group (walla) recording — scene, crowd type, content and status — so background voices are organised for the session. Client-side CSV.

Track which audio stems and mix versions are delivered — D/M/E, printmaster, near-field, stems by reel — with format and status. CSV export, saved locally.

Validate SRT/VTT subtitles against the Netflix Timed Text Style Guide: 17 CPS (adult), 42 characters per line, 2 lines, 5/6 s to 7 s duration.

Check captions against Amazon Prime Video's timed-text spec: up to 20 CPS, 42 characters per line, 2 lines, minimum 5/6 s.

Validate subtitles against BBC Subtitle Guidelines: ~160–180 wpm reading speed, max 37–40 characters per line, 2 lines.

Sanity-check closed captions against FCC quality benchmarks — completeness, timing/synchronicity and placement — for US broadcast and online video.

Check uploaded YouTube captions for reading speed, line length and overlaps so they're readable and don't trip auto-rejection.

Validate subtitles to Disney+/streaming house style: 17 CPS reading speed, 42 characters per line, 2 lines, minimum 5/6 s.

Children's programming needs slower subtitles — validate against the gentler reading speeds (≈ 13–20 CPS) used for young audiences.

Validate teletext-style broadcast subtitles to the classic EBU constraint: ≤ 37 characters per line, up to 2 rows, conservative reading speed.

Quality-check SDH (Subtitles for the Deaf and Hard-of-hearing) for reading speed, line length and timing — the accessibility deliverable studios require alongside dubs.

A general subtitle QC pass — characters-per-second, line length, overlaps and durations — for when you just need clean, readable subtitles to no specific platform.

Convert a WebVTT (.vtt) caption file to SubRip (.srt) — stripping cue settings and fixing timestamp punctuation — entirely in your browser.

Convert an SRT or VTT subtitle file to clean WebVTT for HTML5 video, with correct timestamp formatting and a valid WEBVTT header.

Shift every cue in an SRT/VTT forwards or backwards by a precise number of seconds to fix subtitles that run early or late.

Re-time subtitles between frame-rate families (e.g. 25 → 23.976 fps) when subs drift progressively because they were made for a different cut speed.

Analyze any SRT/VTT for cue count, reading-speed distribution, longest lines and total duration — a quick health snapshot before delivery.

Strip the timestamps and numbering from an SRT/VTT to get a clean, paragraphed plain-text transcript — perfect for blog posts, show notes and SEO.

Turn a plain transcript into a timed SRT by distributing lines across a total duration or a fixed per-cue length — a fast first-pass subtitle file.

Automatically fix overlapping cues and enforce a minimum inter-cue gap (e.g. 2 frames) so subtitles never collide — a one-click cleanup before delivery.

Generate a compliant Digital Cinema Naming Convention content title from structured fields — content type, aspect, language, territory, audio, resolution and packaging.

Hash a batch of delivery files and produce a standard sidecar manifest (shasum/SFV format) to ship alongside your package.

Drop received files and paste a sidecar manifest to verify every file at once — MATCH, MISMATCH, MISSING or extra, per line.

Pick an essence codec and container to see whether the pairing is valid for delivery and which workflow it suits.

Check whether two frame rates belong to the same family (NTSC, PAL, film) — the fast way to predict whether a conform will be clean or need retiming.

Track every required component of a Netflix-style IMF delivery — CPL, video, audio, subtitles, metadata — with status and notes, saved in your browser.

A reusable QC checklist for broadcast file delivery — loudness, video standard, captions, slate, head/tail — track each item to sign-off.

Everything a festival needs from your DCP — naming, KDM, subtitles, format test — tracked so your premiere doesn't fail on screen.

A pre-publish checklist for every podcast episode — loudness, peaks, metadata, chapters, show notes — so each release is consistent.

Convert between bitrate, duration and file size for any encoded video — plan a delivery that fits a size cap or a target bitrate.

Have a hard size cap? Enter the cap, duration and audio bitrate to get the exact video bitrate to encode at.

Estimate Apple ProRes file size from flavour, resolution and frame rate using the published data-rate targets (422, 422 HQ, 4444, 4444 XQ).

Estimate Avid DNxHD/DNxHR file size from the bitrate class and duration — the Avid-native mezzanine equivalent of ProRes.

Estimate a DCP's image data rate and reel size for a chosen JPEG2000 bitrate, against the 250 Mbit/s DCI ceiling.

Compute the data rate and size of uncompressed or camera-RAW video from resolution, bit depth, frame rate and duration.

Sum the storage of a full adaptive-bitrate (HLS/DASH) rendition ladder for a title, so you can budget origin/CDN storage per asset.

Size a full set of broadcast audio stems (dialogue, music, effects, multitrack) at 48 kHz/24-bit for delivery and archive.

Estimate how long a deliverable takes to upload or copy at a given throughput — Aspera, FTP, LAN or internet upload.

Work out how many LTO tapes a media archive needs and the write time, by LTO generation native capacity.

How long can a card record? Enter card size and codec data rate to get recording minutes — for CFexpress, SD and SSD media.

Size total project storage from camera originals, proxies, renders and backups using a multiplier on your raw footage.

Size a polyphonic BWF location-sound reel from track count, sample rate, bit depth and duration for DIT and sound-report planning.

Compare an encoded file against its uncompressed size to get the compression ratio and bits-per-pixel — a quick quality/efficiency gauge.

Generate a SHA-256 checksum for any deliverable and verify it against an expected value — the standard integrity check for media handoffs.

Compute a SHA-1 checksum (hex) and verify against an expected value — still required by many legacy media manifests and ALE/AAF workflows.

Generate a SHA-512 checksum for archival-grade integrity verification of large masters and LTO/archive deliverables.

Compute an MD5 checksum (streamed for multi-GB files) and verify it — the hash most camera/DIT offload tools (Silverstack, ShotPut Pro) write.

Compute the CRC32 of a file — the lightweight checksum embedded in ZIP archives, SFV files and many broadcast-server ingest logs.

Generate the SHA-1, Base64-encoded hash a DCP PKL/asset-map expects for each MXF asset — exactly the format SMPTE 429 packaging tools write.

Generate the SHA-1 Base64 hash an IMF Asset Map / PKL stores for each track file — verify an IMP before delivery to Netflix/studios.

Enter a pixel width and height to get the exact and simplified aspect ratio, plus the nearest named standard (16:9, 2.39:1, 4:3…).

Lock an aspect ratio, enter one dimension, and get the other — pixel-accurate, with optional rounding to an even number for codec compatibility.

See the exact active-image pixels for Flat (1.85) and Scope (2.39) inside the DCI 2K and 4K containers — the numbers a DCP must conform to.

Fit content of one aspect ratio inside a frame of another and get the exact bar height/width and the scaled image size.

Enter a squeezed sensor raster and lens squeeze factor (1.33×, 1.5×, 1.8×, 2×) to get the desqueezed display width and final aspect ratio.

Convert between storage (square-pixel) resolution and display aspect ratio for non-square-pixel formats like DV, HDV and anamorphic SD.

Get the pixel margins for action-safe and title-safe zones in any raster, following the EBU/SMPTE 90%/93% conventions.

Find the largest crop of a given raster that hits a target aspect ratio, with the exact pixels removed from each pair of edges.

Get the recommended export resolution for every social aspect ratio — 9:16, 1:1, 4:5, 16:9 — at a chosen base height.

Compute proxy raster sizes at 1/2, 1/4 and 1/8 of a master, rounded to codec-safe even dimensions for smooth offline editing.

Enter a source and target resolution to get the scale factor and a verdict on whether the upscale will look clean, soft, or visibly degraded.

Convert any video raster to its megapixel count and per-frame pixel total — handy for GPU/VRAM and render-load estimates.

Plan a thumbnail contact sheet: from thumb size, columns and count, get the rows and final sheet dimensions including gutters.

Lay N camera feeds into a grid within an output frame and get the per-tile resolution so each source scales cleanly.

Pick a broadcast format and get its exact active raster, aspect ratio and common frame rates — SD through 8K UHD.

Place source content into a target frame and compare 'fit' (letterbox, no crop) versus 'fill' (crop, no bars) — scale factors and lost pixels for both.

See how a chosen resolution compares to SD, HD, 4K and 8K in pixel count — the multiplier that drives storage, bitrate and render time.

Convert between frame rate and field rate for interlaced formats and see the effective temporal and vertical resolution.

Within a fixed container, compare how many active pixels Flat (1.85) vs Scope (2.39) use and the height difference for hard-matte decisions.

How big can you print a still grabbed from video? Enter the raster and a target DPI to get the maximum clean print dimensions.

Convert a frame count to HH:MM:SS:FF at any frame rate, and back — the everyday math of edit lists, EDLs and conform notes.

Turn a total frame count into real-world runtime (and vice versa) at any frame rate — for reels, DCPs and delivery durations.

See how far drop-frame and non-drop timecode diverge over a given duration at 29.97 fps — the hidden ~3.6 s/hour broadcast drift.

Conform footage from one frame rate to another and see the new runtime and speed change — including the classic PAL 25→24 speed-up.

Convert a 23.976/24 fps film frame count to the 29.97/30 fps fields it becomes through 3:2 pulldown telecine.

Enter in and out timecodes (as total seconds) and frame rate to get the clip duration in frames and timecode — clean clip-length math.

Convert physical film length (35mm/16mm feet) to running time at 24 fps — for archive, lab and film-print planning.

Spot the timing error when an EDL's timecodes are interpreted at the wrong frame rate — the silent cause of drifting conforms.

Split a feature into N reels of a target maximum length and get each reel's start timecode and duration for DCP/lab delivery.

Convert an A/V sync error between milliseconds and frames at any rate, and check it against the EBU R37 ±40 ms perceptibility limits.

From footage shot and final cut length, compute the shooting ratio — the editorial and budget signal of how much was captured per finished minute.

Estimate how long a real-time (tape or live) capture will take, including handles and multiple sources, for ingest scheduling.

Shoot at a high frame rate and play back at base rate — get the slow-motion factor and the real-time duration of your clip.

Add head/tail handles to every clip in a sequence and see the extra frames and media you'll need to pull for the online.

Reconcile a burned-in window timecode against source timecode by computing the constant offset, so notes referencing the BITC map back to source.

Check how Napster will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how Anghami will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how Boomplay will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how JioSaavn will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how Gaana will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how KKBOX will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check how Yandex Music will normalize your master at its -14 LUFS reference, with a −1 dBTP peak guideline.

Check a Short against YouTube's −14 LUFS normalization with a −1 dBTP ceiling — vertical clips get the same treatment as long-form video.

Check phone-system and IVR voice prompts against the telephony-friendly −20 to −16 LUFS range with controlled peaks.

Check an audiobook chapter against the −23 to −18 LUFS window Findaway/library distributors accept, with peaks ≤ −3 dBFS.

Check a sound-effect file's peak normalization and integrated level for consistent library delivery (peak-normalized to −1 to −3 dBFS).

ASMR lives on quiet detail — check that your master sits comfortably below the −14 platform reference yet stays above the noise floor, with safe peaks.

Check an interactive music stem against the −24 LUFS console reference so it sits correctly under dialogue and SFX in the game mix.

LKFS and LUFS are the same unit — this tool confirms the 1:1 relationship and converts to dB-relative-to-target for any standard so you stop second-guessing the acronyms.

Enter a programme length and see how many momentary (400 ms), short-term (3 s) and integrated measurement windows it contains — and which metric to trust for what.

Enter your measured integrated, true peak and LRA plus a standard's limits to get a single pass/fail with the exact margin on every parameter.

For short-form content with a Max Short-term limit, find how loud a 3-second hook can get before it breaches the spec given your integrated target.

Drop an audio file and verify it meets EBU R 128 broadcast loudness: −23 LUFS ±0.5 LU integrated, true peak ≤ −1 dBTP — measured with BS.1770-4 in your browser.

Check a US television deliverable against ATSC A/85 / CALM Act: −24 LKFS ±2 dB integrated, true peak ≤ −2 dBTP.

Validate Japanese broadcast audio against ARIB TR-B32: −24 LKFS ±1 dB integrated, true peak ≤ −1 dBTP.

Check against Free TV Australia OP-59: −24 LKFS ±1 dB integrated, true peak ≤ −2 dBTP.

Verify Canadian TV audio: CRTC enforces ATSC A/85 — −24 LKFS ±2 dB, true peak ≤ −2 dBTP.

Check a UK broadcast file against the DPP technical spec: −23 LUFS ±0.5 LU (EBU R 128) with true peak ≤ −1 dBTP.

QC commercials and short-form content: −23 LUFS ±0.5 LU plus the max short-term −18 LUFS ceiling many EU broadcasters enforce.

Check Italian broadcast deliverables: AGCOM resolution 219/09/CSP aligns Italy to EBU R 128 — −23 LUFS, true peak ≤ −1 dBTP.

Pre-check a Netflix mix: −27 LKFS ±2 dB dialog-anchored loudness with true peak ≤ −2 dBTP, per the Netflix sound mix spec.

Validate against Prime Video's delivery spec: programme loudness −24 LKFS ±2 dB, true peak ≤ −2 dBTP.

Check a Hulu deliverable: −24 LKFS ±2 dB full-programme loudness, true peak ≤ −2 dBTP.

See how Spotify will normalize your master: reference −14 LUFS, recommended true peak ≤ −1 dBTP (−2 dBTP if your master is louder than −14).

Check your video's audio against YouTube's −14 LUFS normalization reference and a −1 dBTP true-peak ceiling.

Check a master against Apple Music's Sound Check reference of −16 LUFS and the Apple Digital Masters −1 dBTP peak guideline.

Check how TIDAL's playback normalization (−14 LUFS reference, album-aware) will treat your master, with a −1 dBTP peak guideline.

Check a master against Amazon Music's ≈−14 LUFS normalization with a −2 dBTP true-peak recommendation.

Check your master against Deezer's −15 LUFS normalization reference with a −1 dBTP peak guideline.

Measure your track the way SoundCloud streams it — no loudness normalization — and sanity-check peaks for the Opus/MP3 transcode.

Check a podcast episode against the industry standard: −16 LUFS stereo (−19 mono), true peak ≤ −1 dBTP.

Validate an episode against Apple Podcasts guidance: −16 LUFS ±1 LU, true peak ≤ −1 dBTP.

Check an episode against Spotify's podcast guidance of −14 LUFS (±2 LU window) with true peak ≤ −1 dBTP.

Run the three ACX technical checks in your browser: RMS between −23 and −18 dB, peaks ≤ −3 dB, and noise floor ≤ −60 dB RMS.

Check game audio against the Audio Standards Working Group home-console reference: −24 LUFS ±2, true peak ≤ −1 dBTP.

Check handheld and mobile game audio against the ASWG portable reference: −18 LUFS ±2, true peak ≤ −1 dBTP.

Check a Reel's audio against the ≈−14 LUFS playback level the platform is widely measured to use, with −1 dBTP safety.

Check a TikTok upload against the ≈−14 LUFS playback level observed on the platform, with −1 dBTP true-peak safety.

Free LUFS meter in your browser: integrated, short-term max, momentary max, LRA, true peak and sample peak — no upload, no install.

Measure inter-sample true peaks (4× oversampled, BS.1770 Annex 2) and check against the −1 dBTP broadcast/streaming ceiling.

Measure LRA per EBU Tech 3342 and interpret it: is your mix over-compressed, comfortable, or too dynamic for the target platform?

Drop multiple files and QC them all against a chosen standard in one table — integrated, true peak, LRA — then export the report as CSV.

Measure a dialogue stem against the −27 LUFS region used as a dialog anchor in OTT mixing, with true peak ≤ −2 dBTP.

QC a trailer or promo for OTT platforms: −24 LKFS ±2 full-mix loudness with true peak ≤ −2 dBTP and a short-form Max ST sanity check.

Check course narration against the −16 LUFS web-audio standard with a tight LRA so learners never ride the volume slider.

Check digital-radio programme audio against the EBU R 128 −23 LUFS target used across DAB+ networks, true peak ≤ −1 dBTP.

QC a near-field home-entertainment remix: −24 LKFS ±2 with true peak ≤ −2 dBTP, the common Blu-ray / home-release practice.

How many dB of gain do you need to hit a loudness target? Enter measured and target LUFS — get the exact gain and your new true-peak estimate.

Turn a measured programme loudness into the correct AC-3 dialnorm metadata value and see the attenuation a decoder will apply.

Enter your master's LUFS and see exactly how many dB Spotify will turn it down (or up) at the −14 LUFS reference, in all three user settings.

See the 'content loudness' figure YouTube will show for your upload and how many dB it gets turned down at −14 LUFS — YouTube never boosts.

One master, six platforms: see the normalization gain Spotify, YouTube, Apple Music, TIDAL, Amazon and Deezer will each apply to your LUFS.

Pick your delivery codec and bitrate class — get the safe true-peak ceiling so the lossy encode doesn't clip, plus your current margin.

Combine the loudness of up to three programme segments into the correct overall LUFS using duration-weighted power averaging — not a misleading dB average.

Estimate the loudness of a full mix from dialogue, music and effects stem measurements using uncorrelated power summation.

Check the LU difference between a commercial and surrounding programme — the number loudness regulation (CALM Act, R 128) actually polices.

Mono and stereo podcasts need different LUFS targets (−19 vs −16). Enter your file type and measurement — get the right target and gain.

Compute PLR — true peak minus integrated loudness — the single best number for how dynamic your master really is.

Compute PSR — true peak minus short-term loudness — the moment-to-moment crush meter used to spot over-limited sections.

Compute crest factor (peak − RMS) for a track, stem or live capture and interpret what it says about compression and headroom.

Pick a Bob Katz K-System scale and get the RMS reference, headroom and the LUFS region it corresponds to for calibrated monitoring.

Convert between dBu and dBFS using the SMPTE, EBU or Japanese studio alignment — know exactly what +4 dBu means in your DAW.

Repurposing a mix between loudness standards? Pick source and destination spec — get the exact gain and the checks to re-run.

Exact uncompressed file size for any WAV/BWF deliverable from sample rate, bit depth, channel count and duration — plus the data rate.

Estimate episode file size from MP3/AAC bitrate and length — and the monthly bandwidth your host serves at your download numbers.

Predict the stereo Lo/Ro level of a 5.1 mix using ITU downmix coefficients — see whether your downmix will clip or duck dialogue.

Check a master against Pandora's −14 LUFS playback normalization with a −1 dBTP peak guideline.

Check streamed-radio audio against iHeartRadio's ≈−14 LUFS normalization and −1 dBTP ceiling.

Check a DJ mix or radio show against Mixcloud's ≈−14 LUFS normalization, with a −1 dBTP safety ceiling.

Bandcamp applies NO loudness normalization — measure how your master will actually play and check peaks for the streaming transcode.

Qobuz favours dynamic hi-res masters with optional −18 LUFS normalization — check your master and its dynamics.

Check a binaural/stereo render of an Atmos music master against the −18 LUFS integrated target Apple/Dolby specify for Atmos streams.

Check a Facebook video against the ≈−14 LUFS playback level Meta is measured to normalize toward, true peak ≤ −1 dBTP.

Check exported Twitch VOD/clip audio against the −14 LUFS web reference with a −1 dBTP ceiling for the AAC stream.

Check a LinkedIn video's audio against the −14 LUFS web-video norm with a −1 dBTP ceiling — important for autoplay-muted-then-unmuted feeds.

Vimeo doesn't loudness-normalize by default — measure your true playback level and check peaks for the H.264/AAC transcode.

Theatrical trailers are capped at 85 Leq(m) by TASA. Check a trailer's full-programme loudness as a pre-screen before a calibrated Leq(m) measurement.

Check French broadcast/cinema-adjacent deliverables against CST RT-017: −23 LUFS, true peak ≤ −1 dBTP, with the French ±1 LU programme tolerance.

Check Brazilian TV audio against ABNT NBR 15602-3 loudness: −23 LUFS target, true peak ≤ −1 dBTP.

Check Korean TV deliverables against the KCC loudness rule: −24 LKFS ±2 dB, true peak ≤ −2 dBTP.

Check Indian TV/OTT audio against the −24 LKFS practice major Indian broadcasters adopted, true peak ≤ −2 dBTP.

Check deliverables for Nordic public broadcasters (NRK, SVT, DR, YLE): EBU R 128 −23 LUFS with the strict ±0.5 LU file tolerance.

Compute the theoretical dynamic range and SNR of any PCM bit depth using the 6.02·n + 1.76 dB rule.

Set a peak target and known crest factor to find the RMS/VU level your tracks should hit for clean digital gain staging.

Find the per-speaker SPL to dial in for a calibrated mix room from the reference standard and number of channels.

Estimate safe daily listening time at a given headphone SPL using the NIOSH 3 dB exchange rate — protect your ears in long mix sessions.

Convert between EBU/BBC PPM scale marks and dBFS using the standard alignment (PPM 4 / 'Test' = −18 dBFS).

Estimate the DR (dynamic range) value used by the Pleasurize/TT loudness-war database from peak and RMS, and see where your master sits on the DR scale.

Compute the ReplayGain 2.0 track gain tag from a measured loudness against the −18 LUFS reference used by foobar2000, MusicBrainz and others.

Pick a genre and delivery context and get a recommended integrated-loudness and PLR target that balances competitive level with streaming-normalization survival.

Comparing two processing chains or masters? Enter both LUFS values to get the exact trim that makes the A/B fair — louder always sounds 'better' until you match level.

Scan an audio file for clipped (full-scale) samples and consecutive-sample clip runs, with a per-channel count and the worst timestamps — all in your browser.

Measure the DC offset of each channel and tell you whether it needs a DC-blocking high-pass before mastering or delivery.

Compute the stereo correlation coefficient and mono-compatibility of a file — catch out-of-phase mixes that collapse on mono playback before delivery.

Detect head and tail silence and long internal gaps in an audio file against a dBFS threshold — essential before broadcast and podcast delivery.

Drop any audio file to read its real decoded sample rate, channel count, duration and estimated bit depth — verify a deliverable matches spec before you send it.

Render the average frequency spectrum of a file (FFT) so you can spot a missing low end, harsh highs, or a hard low-pass before signing off a master.