A small local Python command-line tool for inspecting videos and creating DaVinci editing intermediates with FFmpeg, with an optional desktop window. Source files are retained.
The desktop window can optionally upload prepared MP4 files to Gemini with an editable prompt and save the completed local response as a native Google Doc.
On Linux Mint or Ubuntu, install VideoTool for your own user account from this folder:
python3 install-videotool.pyThis adds the VideoTool icon to the application menu and a videotool launcher
under ~/.local/bin. It copies only the application code and documentation into
the standard user data directory. It does not use sudo, install system-wide
files, copy footage, or include credentials, caches, histories, receipts, or
generated videos. After installation, launch VideoTool from the application
menu without opening a terminal or VS Code. If the menu does not refresh
immediately, sign out and back in once.
To install the optional Gemini Python packages at the same time, use:
python3 install-videotool.py --with-geminiThat optional flag creates an isolated environment inside the managed VideoTool
installation and downloads the packages listed in requirements-gemini.txt. The
API key is still entered later through Gemini key… and remains in private
per-user credential storage. A package-download failure leaves the local conversion app
installed and allows a later retry.
The application menu provides Help → About VideoTool, which shows the installed app version and readiness for Python, Tkinter, FFmpeg, ffprobe, and optional Gemini support. The same read-only report is available with:
videotool --healthAfter downloading or pulling a newer VideoTool source folder, update only the managed installation with:
python3 install-videotool.py --updateAdd --with-gemini if the optional packages should also be installed or refreshed.
The updater refuses to overwrite an unrecognized installation and never downloads
new VideoTool source code by itself, making the version being installed explicit.
Uninstall the managed app, launcher, menu entry, icon, and installer-created environment with:
videotool-uninstallYour VideoTool preferences and privately saved Gemini key are preserved. To also
remove the non-secret preferences, use videotool-uninstall --remove-settings.
The key remains in credential storage; remove it through Gemini key…
before uninstalling if you do not want to retain it.
Hover over any button for a short explanation, including buttons that are currently disabled. Hints disappear when you move away, click, press Escape, or change focus. The page scrolls when the window is shorter than its contents. Narrow windows stack the format, source, and Gemini sections instead of clipping them, while the status and primary Preview/Run actions remain visible at the bottom. Gemini's main and creator prompts use tabs when both are needed. The same VideoTool film-and-arrow mark identifies the application menu, window title bar, and page header.
On Linux Mint/Ubuntu, install the window library once:
sudo apt install python3-tkOpen the interface from the VideoTool folder:
./run-videotool.shRunning python3 videotool_gui.py from this folder also switches automatically
to the isolated VideoTool environment when it is available.
- Choose a preparation preset, then use Choose source to select one video or a folder. To make the picker open on a particular drive or folder in future sessions, open Starting folder… and choose Choose starting folder. Use Use normal system folder there to return control to the operating system. For upload presets, choose finished DaVinci exports. DaVinci copies automatically preserve source bit depth. Open Advanced settings only when you want to use a DNxHR MOV that you have already confirmed works in Resolve as a format reference.
- Optionally open Output folder to choose an existing folder or create a new folder inside a selected parent; otherwise copies go beside the originals.
- Optionally enter a location under Name files by location, such as
Dublin, for names likeDublin_001.mov,Dublin_002.mov. Leave it blank to keep the default names. - Click Preview. The list shows source size, duration, detected bit depth, approximate output size, output name, and color-coded status. Select a row to reveal its full paths, format, estimate explanation, or error.
- Review the ready files and click Convert ready files to confirm and start. Progress, retry, receipt, and output-folder controls appear when they are useful.
When the desktop Tcl/Tk installation provides TkDND, a video or folder can also be dropped onto the window. Choose source remains available on systems without that optional support. The optional starting folder is stored in the normal per-user configuration location and does not select, scan, or alter any footage by itself. If that folder is later unavailable, the picker safely returns to its normal system location.
Location numbering continues after the highest existing number in the output
folder: if Dublin_007.mov exists, new files start at Dublin_008.mov. Gaps are
not reused. Existing files, folders, and links reserve their names, including
case variants. New sources are numbered in filename sort order. Changing the
location requires a new preview. Existing numbered exports for that location
are excluded from the folder scan. Spaces and accented letters are supported;
path separators and special filename characters are refused.
Successful conversions made by this version are recorded in a small hidden
.videotool-history.sqlite3 file in the output folder. When the original source,
location, and recorded output still match, a later preview shows Done and
skips conversion. This works after closing the app and when adding footage to
an existing source folder. Keep the history file with the output folder. If
saving history fails, the completed row shows a warning; the open window still
remembers its successes.
Each run that completes at least one video also creates a human-readable Markdown
file named VideoTool-processing-YYYYMMDD-HHMMSS.md in the output folder. It
records the source and output paths and sizes, video and audio formats, preset
parameters, exact FFmpeg command or two-pass commands, FFmpeg version, source
duration, per-file elapsed time, effective speed relative to realtime, validation
scope, and batch totals. View processing receipt opens the latest record;
Copy summary copies the latest run counts, elapsed time, and receipt location.
The command-line davinci --execute and batch --execute workflows create the
same receipt format.
Receipt timing measures local encoding time for each file. Batch timing covers the attempted run. The SQLite history also stores source/output sizes, duration, elapsed time, conversion speed, and the associated receipt name for newly completed files. Existing history databases need no migration; older entries without these fields remain readable.
The receipt distinguishes local validation from external testing. “Completed” means FFmpeg finished and VideoTool performed its available local checks. It does not mean DaVinci Resolve successfully imported the file, or that AI Studio or YouTube accepted an upload. If the Markdown file cannot be written, completed video remains successful and the interface reports the receipt error.
Older exports without a history record reserve their numbers, but the app cannot reliably identify which source created them. When adding footage to those older exports, select only the new footage or put new sources in their own folder. Use a separate output folder when working with exports from several locations.
The window stays responsive while inspecting or converting. It shows each file's status and a final results summary. Stop after current file lets the active conversion finish, then leaves the remaining files unprocessed. Cancel current conversion terminates the active FFmpeg process and also stops the batch. The current file is marked Interrupted, is never recorded as successful, and any partial output remains in place. Files later in the batch do not start. During an AI Studio two-pass conversion, cancelling during or after the first pass prevents the second pass from starting; because pass one does not create the target file, there may be no partial output in that case. Close the window after work finishes.
After a failure, stop, or cancellation, click Preview retry, review the new list, then
Convert ready files. Completed files remain Done and are not converted
again. Unfinished files keep their planned names when available. A partial or
existing output is retained; the retry gets the next location number, or a
unique _retry_001_davinci.mov suffix when no location is entered. No existing
output is deleted or overwritten. The retry preview inspects sources again,
so repaired inputs can be retried.
The completion summary shows completed, failed/blocked, and unfinished counts across the list, including prior successes, and the destination path. Open output folder opens that folder in the desktop file manager (or the selected row's output folder if there is more than one). Progress percentages during a retry describe only the remaining ready files.
For folder previews, a storage banner identifies the number of ready files, their combined estimated output, destination free space, and the estimated remaining space or shortfall after the complete batch. DaVinci estimates include 10% planning headroom. Upload estimates are explicitly approximate because encoded sizes vary. The selected-row details label the estimate as applying to that file only.
Only files captured in the preview are converted. Changing the selection requires
a new preview, and sources changed since inspection are refused. Existing outputs
are preserved and shown as blocked. Conversion failures do not stop other ready files.
Two progress bars show the current file and the whole batch, with estimated time
remaining based on measured conversion speed. Batch progress is weighted by video
duration across ready files. Estimates appear after initial progress and can change
with clip resolution, codec, or system load. If duration metadata is unavailable,
the corresponding percentage and estimate are unavailable. A file reaches 100%
only after FFmpeg finishes successfully; failures remain visible in the results.
Single-file names use clip_davinci.mov; folder mode uses clip.mp4_davinci.mov.
Python 3.10+, FFmpeg/ffprobe, Tkinter, and a graphical desktop are required. The command-line tool still works without Tkinter.
Use the Prepare for selector in the desktop window:
| Preset | Result |
|---|---|
| DaVinci editing copy | DNxHR/PCM MOV that keeps 8-bit sources at 8-bit and 10-bit sources at 10-bit, or settings learned from a working reference. |
| AI Studio upload | A smaller H.264/AAC MP4, using an adjustable maximum target per file. |
| YouTube upload | A quality-focused H.264/AAC MP4 at source resolution, with no file-size cap. |
Choose the finished export, select the preset, and click Preview to see the output name, dimensions, audio handling, and tradeoffs. Then convert the ready files. The original exports are retained. YouTube files are uploaded manually. The upload presets are desktop features; the existing command-line commands continue to prepare editing copies.
Gemini analysis is optional and applies only to the AI Studio upload preset. Install its supported Google client once in an isolated VideoTool environment:
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements-gemini.txtCreate a Gemini API key in Google AI Studio. In VideoTool, choose AI Studio upload, open Gemini key…, and select Save or replace key. Paste the key once; VideoTool saves it in an owner-only credential file under your normal per-user configuration folder and also uses the operating system password store when available. Application updates do not replace this credential. The same menu can replace or remove both saved copies later.
As an optional temporary alternative, set the key in a terminal before opening VideoTool:
export GEMINI_API_KEY="your-key"
./run-videotool.shVideoTool only shows whether a key was found; it never displays the key or writes it into the project, receipts, or logs. Select Analyze converted video with Gemini to send the prepared MP4 after conversion and reveal the multiline prompt. Paste or edit any text there, or use Restore default prompt. Preview shows the model and exact prompt before any network request. Gemini analysis accepts one ready video at a time; choose a single video rather than a multi-video folder.
To analyze a video that does not need preparation, enable Upload original directly to Gemini (skip conversion). This choice enables Gemini by itself; you do not also select the converted-video option. Select one video file and preview it as usual. The main action changes to Upload original to Gemini; FFmpeg does not run, the original remains unchanged, and the Markdown response is saved beside it. Direct upload accepts the video formats currently listed by Gemini, including MP4, MOV, MPEG, AVI, FLV, WebM, WMV, and 3GPP.
For a finished DaVinci export, enable Compare standard summary with creator review. The standard summary (baseline) is VideoTool's normal chronological summary of the same video using the same Gemini model. It provides the reference for judging what the creator-focused prompt adds. Preview shows the exact local video, Gemini model, both editable prompts, one planned upload, two planned model requests, and the local report destination. Preview is local: no Gemini client or network request starts until you press Run creator benchmark. The source is uploaded once and reused first with the normal summary prompt, then with a creator-review prompt focused on the selected Analysis purpose:
- Publishing package — titles, description, chapters, thumbnail concepts and candidate frames, and Shorts opportunities;
- Find Shorts — ranked timestamped clips, hooks, titles, edit requirements, and useful candidate frames;
- Review yoga sequence — poses, transitions, repeated sides, sequence coverage, visible clarity, and uncertain identifications;
- Check final video — confirmed issues, optional improvements, and prioritized fixes across pacing, continuity, clarity, audio, visuals, text, and structure;
- Generate chapters — complete, useful chapters with meaningful boundaries, specific titles, and short descriptions.
Both prompts remain editable. VideoTool keeps a separate creator-prompt draft for each purpose when you switch between them. Restore purpose prompt resets only the currently selected purpose. No conversion runs and the source stays in place.
The benchmark saves separate standard-summary baseline and creator-review Markdown responses plus a comparison report beside the source. Names are collision-safe, completed results survive a later failure, and the report includes measured timings, upload size, request counts, the selected purpose, both exact prompts, and a focused blank human rating table. Across the purposes, the rubric covers timestamp accuracy, completeness, pose/content recognition, chapter usefulness, publishing copy, thumbnail candidates, Shorts, hallucinations, creator corrections, hands-on time, processing time, upload friction, and repeatability where relevant. Subjective scores remain blank; only measured values are filled automatically. The comparison tests prompts and workflow. Cancel Gemini benchmark prevents the next online stage. A Gemini SDK request already in progress must return before cancellation takes effect. Uploaded Gemini files are currently left to Gemini's service retention; VideoTool does not issue remote cleanup requests.
For a fuller answer that uses both representations, enable Combine native video with selected frames. Choose one finished video and edit the normal Gemini prompt. Preview shows the exact video, model, prompt, planned local frame selection, three Gemini requests, and saved artifacts before anything starts. Run combined analysis then:
- uses FFmpeg locally to select scene changes and regular intervals, capped at 48 frames, and stamps each image with its video timestamp;
- creates a contact sheet beside the source;
- sends the native video to Gemini with the reviewed prompt; and
- sends the selected stills to the same Gemini model with that exact prompt; and
- asks the same model to reconcile both preliminary results into one final answer that follows the original prompt.
VideoTool saves both preliminary Markdown responses, the combined final response, and a comparison report beside the source. The report contains measured timings, selected timestamps, preserved artifact names, and a blank rating table for comparing all three results. The selected-frame input has timestamps but cannot hear audio or see continuous motion, while the native-video input retains both. The final request uses the native result for sound and movement and the frame result for visible text, visual detail, and explicit frame timestamps. Gemini performs all three stages; this mode does not run a local AI model. The original video is read and verified after the run; it is never converted or modified. Temporary individual frames are removed afterward, while the contact sheet and reports are retained. The source folder must be writable.
The final combination policy omits speculative locations, identities, causes, and intentions unless the user's prompt asks for possibilities. Unsupported candidates from a preliminary response are reduced to a plain uncertainty, such as saying that the location cannot be identified from the video. Timestamps derived from sampled frames are described as approximate visibility windows. The exact policy is included in the combined response file and comparison report.
If Gemini reports a temporary 503 service-unavailable or high-demand condition during any analysis request, VideoTool automatically retries that request after 2, 5, and 10 seconds. It does not repeat the completed upload or earlier analysis stages while the run remains open. A non-temporary error still stops immediately, and exhausting all retries preserves every result already completed.
After an incomplete combined run, selecting the same video with the same model and unchanged prompt automatically offers a resumable plan in Preview. Running it reuses the saved native-video response and does not upload the video or repeat that Gemini request. VideoTool locally rebuilds temporary frames, continues with the first unfinished Gemini stage, and also reuses a completed selected-frame response when available. The original incomplete report remains unchanged; the resumed attempt saves a separate recovery report. Changing the video, model, prompt, or source file size starts a new analysis instead. The preview displays a prominent Resume available banner and changes the status to ready to resume from saved results, so recovery is visible without scrolling through the selected-file details.
The current default model is gemini-3.8-flash. Set VIDEOTOOL_GEMINI_MODEL
before starting the app to use another model. Every non-empty response is saved
beside the MP4 as VideoTool-Gemini-...md, and View Gemini response opens the
latest file. Upload, processing, or model errors leave the converted MP4 marked
successful. Select the video and use Copy error/details to copy the complete
failure message for troubleshooting. The cancel control prevents later Gemini stages from starting.
Gemini use is subject to the quota, billing, and data handling of the Google API
project associated with the key. Benchmark reports require the source folder to be
writable. A project shown as Restricted in Google AI Studio must be resolved or
replaced with an eligible active project before VideoTool can call Gemini.
The intended first manual benchmark is the V2 yoga finished video, followed later
by A01 Kinsale Bay. Neither source is used by automated tests or implementation checks.
VideoTool can save a successful local Gemini response as a native Google Doc in My Drive / VideoTool Gemini Results. Enable Save final response to Google Drive before Preview. The exact local Markdown result is always saved first. If Drive is unavailable, the Gemini result remains successful and Retry Google Drive retries only the existing local response. Google Drive… → Save an existing local response provides the same recovery after restarting the app.
Google requires a one-time desktop-app connection:
- In Google Cloud, enable the Google Drive API and Google Docs API for a project.
- Configure the Google Auth consent screen and add the Google account that will use VideoTool as a test user when the app is in testing mode.
- Create an OAuth client with application type Desktop app and download its JSON file.
- In VideoTool, open Google Drive… → Choose setup file and connect, select that JSON file, and approve access in the browser.
VideoTool privately copies the desktop OAuth setup and refreshable user token to
the normal per-user configuration folder with owner-only permissions. Updates do
not replace them. The app requests the narrow drive.file permission, which lets
it create and manage the result folder and documents it creates without browsing
unrelated Drive files. Open Google Doc opens the completed result. A local
.drive.md receipt beside the Gemini Markdown records the Doc link and ID; a
private machine-readable sidecar prevents duplicate delivery retries.
Google sign-in can be cancelled from VideoTool and times out after five minutes if
the browser sign-in is abandoned or rejected. Closing VideoTool during sign-in
also closes it immediately.
If the optional Drive libraries are missing, update the managed app with online support from the VideoTool source folder:
python3 install-videotool.py --update --with-geminiOfficial setup references: Drive Python quickstart, Drive folders, and Google Docs creation.
The default 380 MB is a user workflow target chosen to leave headroom under the user's observed possible 400 MB upload cap. It is not a verified universal AI Studio limit. There is no five-minute cutoff. The target is per output file, uses decimal MB (1 MB = 1,000,000 bytes), and accepts values from 1 to 100000 MB.
Encoding uses two passes with a bitrate budget leaving 5% for overhead and variation. The longest edge is limited to 1920 pixels, or 1280 if the available bitrate is too low; videos are never upscaled. Frame rate is retained as the source average at constant frame rate. The preview shows the chosen dimensions and bitrate. It estimates output from that bitrate, duration, and planned audio, while the entered size remains a hard maximum. Video bitrate is capped at 8 Mb/s for this analysis-oriented copy.
A preset guard refuses targets below the greater of 500 kb/s or 0.05 bits per pixel per frame at the smallest chosen dimensions. This is a practical quality floor, not a guarantee of visual quality. Increase the size target or export shorter sections from DaVinci if it is refused.
The bitrate calculation is an estimate. Actual size is checked after encoding, along with codec, dimensions, audio, and duration. A result above the target is preserved but marked failed, not ready, and is not saved as a successful conversion. No output is silently truncated to meet the target. Retry uses a new name if the old output exists. AI Studio's acceptance still needs a manual upload check.
The preset follows YouTube's official upload encoding guidance, checked on 2026-09-06: fast-start MP4, H.264 High Profile with 4:2:0 video, progressive frames, closed GOPs, and AAC-LC audio at 48 kHz. It uses quality-based variable bitrate (CRF 18, slow preset), retaining resolution except even-pixel rounding and the source average frame rate. CRF 18 is VideoTool's quality choice, not a YouTube requirement. Stereo audio uses 384 kb/s; mono uses 128 kb/s. There is no size cap. The preview gives a rough storage-planning estimate based on output resolution, frame rate, duration, and audio. Motion and picture detail can make the actual file much smaller or larger, so the estimate is never presented as a limit or guarantee.
These upload presets expect progressive, square-pixel SDR Rec.709 YUV exports. Known HDR, other tagged color spaces, interlacing, and rotation metadata are refused with instructions to prepare a suitable finished export in DaVinci. Missing color tags are called out in the preview: confirm that the source is a finished SDR export. No HDR/log tone mapping is performed. Upload copies are 8-bit, lossy derivatives.
One audio track is included (the sole track or a uniquely marked default). Surround audio is mixed to stereo, as disclosed in the preview. Silent exports are supported. Subtitle, data, and other audio tracks are omitted.
Upload presets can scan incoming _davinci.mov files. They exclude their own
_aistudio.mp4 and _youtube.mp4 outputs and recognised upload receipts from folder
scans. Use a folder of finished exports, preferably with a separate destination.
Default names include the preset, such as Finished_aistudio.mp4 and
Finished_youtube.mp4. Location naming uses sequential .mp4 names and continues
past existing numbers. Retry, progress, completion summaries, and hover hints work
for all presets. AI Studio progress covers both passes. Saved successes are scoped
to the preset and AI size target, so one preparation cannot stand in for another.
-
Open this VideoTool folder in VS Code.
-
Choose Terminal → New Terminal. The terminal should be in this folder.
-
Run the following, replacing the example path with your video's full path. Keep the quotes, especially if the path contains spaces:
python3 videotool.py inspect "/full/path/to/video.mp4"
The summary shows the container, duration, file size, video codec, dimensions, average frame rate, pixel format, color metadata, and audio information. Missing metadata is shown as unknown. Metadata alone does not certify DaVinci Resolve compatibility.
For the full metadata or help:
python3 videotool.py inspect "/full/path/to/video.mp4" --json
python3 videotool.py --help
python3 videotool.py inspect --helpRequirements: Python 3.10+ and FFmpeg with ffprobe on PATH. Local-only use needs
no Python package installation; Gemini analysis uses the optional requirements file.
Python 3.12.3 and FFmpeg
6.1.1 were available on this machine when this was created.
inspect reads a local regular file and runs
ffprobe with a 60-second timeout. Missing files, unreadable media, files without
video, and missing ffprobe produce an error and a nonzero exit code.
validate_output() refuses source
reuse, existing output files (including hard links), symbolic-link outputs, and
missing destination folders. FFmpeg also uses -n to refuse overwrites at
execution time. If a conversion fails or is interrupted, a partial output may
remain. Review it yourself; the tool will not delete or overwrite it.
Preview first; this command reads metadata and creates no output:
python3 videotool.py davinci "1.MP4"It prints the exact source, proposed output, selected streams, tradeoffs, and
FFmpeg command. The default output is 1_davinci.mov beside the original.
Use --output "/full/path/new-name.mov" to choose another new path in an existing
folder. Existing files are always refused.
After reviewing and approving that exact operation, adding --execute creates
the output. Running this yourself explicitly confirms the conversion:
python3 videotool.py davinci "1.MP4" --executeWhen an assistant is operating this tool, it must present the exact source, output, purpose, and significant tradeoffs and obtain your explicit confirmation before executing a conversion on your media.
The automatic MOV format checks the source video depth. It uses DNxHR SQ with 8-bit 4:2:2 video for 8-bit footage and DNxHR HQX with 10-bit 4:2:2 video for 10-bit footage. Audio uses uncompressed 16-bit PCM. A mixed folder is decided one file at a time. Unknown, conflicting, and unsupported source depths are refused instead of being silently reduced. These editing copies remain much larger than camera HEVC, so keep the original camera files as masters. Upsampling 4:2:0 to 4:2:2 adds no captured detail, and PCM cannot restore detail already lost in AAC.
Use Choose reference in the window when you have a DNxHR MOV already verified in Resolve. VideoTool reads that file and reuses its DNxHR profile (LB, SQ, HQ, or HQX), pixel depth, and PCM depth. Choosing a reference explicitly overrides the automatic source-depth choice. It rejects non-DNxHR video, non-PCM audio, unexpected pixel formats, and ambiguous primary video. A reference is a format example only; its resolution, frame rate, and channel layout are not imposed on new footage. Selecting an HQX reference will deliberately produce large HQX files; selecting LB makes much smaller files with lower editing-copy quality.
Preview shows a cautious output-size estimate with 10% headroom and the free space in the destination. Estimates based on a reference use its measured data rate, scaled for the new resolution and frame rate. Automatic SQ/HQX estimates use profile-rate approximations. Conversion checks free space again immediately before starting and refuses a file when its estimate exceeds the available space. The estimate is planning guidance rather than an exact output-size guarantee.
Resolution, frame timing, and audio sample rate/channel count are retained. No LUT, tone mapping, scaling, or automatic rotation is applied; known source color tags are carried forward.
The tool selects the sole normal video stream, or a uniquely marked default video stream. Ambiguous selections are refused. Attached images and thumbnails are excluded; all audio streams are included. Data, subtitles, and timecode tracks are omitted. Variable-frame-rate sources keep their frame timing; this command does not normalize them for editing.
Codec choice is based on Blackmagic's Resolve 20 supported codec list, Linux tables on pages 11 and 14: DNxHR MOV and PCM are supported; H.264/H.265 decode is Studio-only and AAC is unsupported. The published Linux table targets Rocky Linux/CUDA; actual import on your installation still requires a picture and sound check in Resolve. On 2026-09-05, the user confirmed that a file converted by VideoTool works in DaVinci Resolve. See test results for the recorded result and scope. FFmpeg option reference: official documentation.
The desktop window also provides the YouTube and AI Studio preparation workflows described above.
Preview videos directly inside a folder:
python3 videotool.py batch "/full/path/to/footage"To learn from a previously verified DNxHR/PCM file, add --reference during
both preview and execution:
python3 videotool.py davinci "1.MP4" --reference "/path/to/working_DNxHR_SQ.mov"
python3 videotool.py batch "/full/path/to/footage" --reference "/path/to/working_DNxHR_SQ.mov"After reviewing the plan, convert the ready files:
python3 videotool.py batch "/full/path/to/footage" --executeUse --output-dir "/full/path/to/exports" with either command to select an
existing destination folder. By default, outputs are beside the sources.
Names include the original extension: clip.mp4 becomes clip.mp4_davinci.mov,
so files with the same stem and different extensions have separate outputs.
The scan includes MP4, MOV, MKV, AVI, M4V, MTS, M2TS, WEBM, MPG, MPEG, and MXF
(case-insensitive). Subfolders, symbolic links, and names ending in
_davinci.mov are excluded. Each candidate is inspected before conversion.
Existing outputs are reported as failures and preserved; other ready files
continue. A failed or partial output is never deleted automatically.
Conversions run one at a time, with a file counter and final success/failure counts. Ctrl+C during conversion stops the batch; remaining files are reported as not attempted. Exit status is 0 for success, 1 for any failure, or 130 for an interrupted conversion. Progress is per file, not a percentage within a file. Preview reports estimated batch output and available space. Allow ample disk space for the much larger DNxHR outputs.
Tests use temporary dummy files, simulated ffprobe responses, and a tiny generated test clip when FFmpeg is installed. They never process your footage:
python3 -B -m unittest discover -s tests -v