Notebook on

Extract the Start Timecode from a Quicktime Movie

Sun, 10 May 2026 18:55:19 -0700

This is a trifle but I was stuck on it for some time, even if you follow all of the documentation there’s a trick to it.

import AVFoundation
import CoreMedia

enum MovieTimecodeExtractionError: Error {
 case IntegrityError
}

enum MovieTimecodeExtractionResult {
 case Success(CMTime)
 case NoTimecodeTrack
 case NoTimecodeSamples
}

/// Get the first timecode value from a movie file.
///
/// This function uses AVFoundation and will attempt to load timecode tracks from the
/// given movie. This is appropriate for QuickTime `.mov` and `.mp4`-type files.
///
/// If the movie was succesfully read, the function will either return the time value as a
/// `CMTime` if timecode was found, or `nil` if
/// - The movie contained no timecode track, or
/// - The movie contains a timecode track but that track has no timecode samples
///
func extractStartTimecode(from url: URL) async throws
 -> MovieTimecodeExtractionResult
{
 let asset = AVURLAsset(url: url)

 // all of this is pretty straighforward...
 guard
 let timecodeTrack = try await asset.loadTracks(withMediaType: .timecode)
 .first
 else {
 return .NoTimecodeTrack
 }

 let reader = try AVAssetReader(asset: asset)
 let output = AVAssetReaderTrackOutput(
 track: timecodeTrack,
 outputSettings: nil
 )
 reader.add(output)
 guard reader.startReading() else {
 throw reader.error!
 }

 // This is where I got tripped-up...
 // What I didn't know was that the `output` here can (and does) return
 // valid sampleBuffers that, despite being valid, contain no data...
 while let sampleBuffer = output.copyNextSampleBuffer() {

 guard
 let formatDescription: CMFormatDescription =
 CMSampleBufferGetFormatDescription(sampleBuffer),
 let blockBuffer: CMBlockBuffer = CMSampleBufferGetDataBuffer(
 sampleBuffer
 )
 else {
 // ...so I'd get here, and when these two were nil, I initially assumed
 // that this meant the output was exhausted. Not the case!
 //
 // If these are nil, that just means this sampleBuffer was empty, but
 // there are more sampleBuffers and the output will return these from
 // copyNextSampleBuffer, and you should only stop iterating the output
 // when copyNextSampleBuffer returns nil.

 // If we're here, either of these were nil, and so the correct thing
 // to do now is to advance to the next sampleBuffer.
 continue
 }

 let frameQuanta = CMTimeCodeFormatDescriptionGetFrameQuanta(
 formatDescription
 )

 var rawData: UnsafeMutablePointer<Int8>? = nil
 var length: Int = 0
 var totalLength: Int = 0

 let error = CMBlockBufferGetDataPointer(
 blockBuffer,
 atOffset: 0,
 lengthAtOffsetOut: &length,
 totalLengthOut: &totalLength,
 dataPointerOut: &rawData
 )

 guard error == kCMBlockBufferNoErr else {
 throw NSError(domain: NSOSStatusErrorDomain, code: Int(error))
 }

 guard let tcData = rawData else {
 // I'm not sure how we would get here if error was noErr.
 throw MovieTimecodeExtractionError.IntegrityError
 }

 let type = CMFormatDescriptionGetMediaSubType(formatDescription)
 let frames: CMTimeValue?

 switch type {
 case kCMTimeCodeFormatType_TimeCode32:
 let fr0 = tcData.withMemoryRebound(
 to: UInt32.self,
 capacity: 1,
 { CFSwapInt32BigToHost($0.pointee) }
 )
 frames = CMTimeValue(fr0)

 case kCMTimeCodeFormatType_TimeCode64:
 let fr0 = tcData.withMemoryRebound(
 to: UInt64.self,
 capacity: 1,
 { CFSwapInt64BigToHost($0.pointee) }
 )
 frames = CMTimeValue(fr0)

 default:
 // IF we're here, `type` is probably one of the
 // kCMTimeCodeFormatType_Counter* values, which are not useable to
 // this function
 frames = nil
 }
 reader.cancelReading()

 return frames.flatMap {
 .Success(
 CMTime(
 value: $0,
 timescale: CMTimeScale(frameQuanta)
 )
 )
 } ?? .NoTimecodeSamples
 }

 // We're here if the `while` never found a timecode databuffer
 switch reader.status {
 case .completed:
 return .NoTimecodeSamples
 case .failed:
 throw reader.error!
 default:
 throw MovieTimecodeExtractionError.IntegrityError
 }
}

Doodles: Tuning Systems

Wed, 08 Apr 2026 17:53:13 -0700

Some prelimiaries…

%pip install tabulate

import math
import itertools
from IPython.display import display, HTML, display_html, display_markdown,
 Markdown
from tabulate import tabulate

type Hz = float
type Note = int

A_440_Note = 69
A_440_Hz = 440.0

def note_class(n: Note) -> tuple[int, int]:
 octaves, steps = divmod(n, 12)
 return octaves - 1, steps

def note_name(n: Note) -> str:
 # MIDI note 24 is C1
 note_names = ['C', 'C♯/D♭', 'D', 'D♯/E♭', 'E', 'F', 'F♯/G♭', 'G', 'G♯/A♭',
 'A', 'A♯/B♭', 'B'] octaves, steps = note_class(n)
 return f"{note_names[steps]}{octaves}"

assert note_name(24) == 'C1'

12-TET Tempering

12-tone Equal Temperament divides an octave into a twelve logarithmically-equal parts. This is convenient because it has a very compact closed-form expression.

Slate with FFmpeg

Fri, 14 Nov 2025 10:53:13 -0800

This is a little buggy with certain input movies but generally works great for anything prores or h264 at standard 1080p resolution.


#!/bin/bash

# slated_output.bash 
# Add slate to the beginning of a movie 
# by Jamie Hardt
# (c) 2025 Squad 51 Inc. All rights reserved.

# This will add:
# - a slate to the beginning of the input movie
# - Three thumbnails taken from pre-selected times in the input movie will be 
# on the slate
# - A lower-third text will be printed to the entire length of the outpu 
# - Then entire output will be standardized to 1920x1080
# - Audio output is 48000 pcm_s24le
#
# The INPUT_FILE is expected as argument 1 on the command line, the idea being
# you might make a copy of this script for each project and customise the
# thumbnail positions, client and title, while the movie always changes.
# 
# The output file will be name INPUT_FILE_slated.

# Enter project info here
HEADLINE="SOUND DESIGN REVIEW"
TITLE="\"TITLE\""
CLIENT="CLIENT"
CONTACT="CONTACT"
PIX_REF="PIC_REF"
MESSAGE="MESSAGE"

# Enter the times for each thumbnail here
THUMB1_TIME="00:00:37"
THUMB2_TIME="00:08:39"
THUMB3_TIME="00:11:00"

MESSAGE_COLOR=yellow

# Enter the slate duration in seconds
SLATE_DURATION="1"

# Set a number here to play a test tone at -20 dBFS under the slate. Don't set 
# it and the slate will be silent
# SLATE_TONE=440

# Font for slate titles. Leave it unset for the default
FONT=/System/Library/Fonts/Avenir.ttc

# Set this to "-to 20" while you're testing your script out, once it looks 
# right then set it to ""
OUTPUT_LENGTH_ARG="-to 20"

# Set this to a positive number to move the middle block, the HEADLINE, TITLE 
# and CLIENT fields down/south, to avoid covering the thumbnails.
MIDDLE_Y_NUDGE="80"

# Set this to a positive number to move the lower-third and "file" field in 
# the slate up/north, to avoid covering burnins
BOTTOM_Y_NUDGE="0"



#################################################################################
#####
##### DON'T EDIT BELOW THIS LINE


if [ ! -z $FONT ]; then
 FONT=":fontfile="$FONT
fi

INPUT_FILE="$1"
INPUT_BASENAME=$(basename -- "$INPUT_FILE")
OUTPUT_FILE=$(dirname -- "$INPUT_FILE")/"${INPUT_BASENAME%.*}_slated.mov"

# Escape title, client and message fields in case they have quotes or colons
TITLE=$(echo -n $TITLE | ffescape -p "" -s "':" | ffescape -p "")
CLIENT=$(echo -n $CLIENT | ffescape -p "" -s "':" | ffescape -p "")
MESSAGE=$(echo -n $MESSAGE | ffescape -p "" -s "':" | ffescape -p "")

SLATE_AUDIO="-f lavfi -t $SLATE_DURATION -i "
if [ -z $SLATE_TONE ]; then
 SLATE_AUDIO+=anullsrc=r=48000:cl=stereo,aformat=sample_fmts=s32:\
 channel_layouts=stereo
else
 SLATE_AUDIO+="sine=$SLATE_TONE:r=48000,aformat=sample_fmts=s32:"
 SLATE_AUDIO+="channel_layouts=stereo,aeval=val(ch):c=same"
fi

ffmpeg -y -hide_banner \
 -f lavfi -i "color=c=black:s=1920x1080:d=$SLATE_DURATION" \
 -ss $THUMB1_TIME -i "$INPUT_FILE" \
 -ss $THUMB2_TIME -i "$INPUT_FILE" \
 -ss $THUMB3_TIME -i "$INPUT_FILE" \
 -i "$INPUT_FILE" \
 $SLATE_AUDIO \
 -filter_complex "
 [1:v]trim=duration=0.04,setpts=PTS-STARTPTS,scale=560:-1,
 tpad=stop_mode=clone:stop_duration=$SLATE_DURATION[thumb1];
 [2:v]trim=duration=0.04,setpts=PTS-STARTPTS,scale=560:-1,
 tpad=stop_mode=clone:stop_duration=$SLATE_DURATION[thumb2];
 [3:v]trim=duration=0.04,setpts=PTS-STARTPTS,scale=560:-1,
 tpad=stop_mode=clone:stop_duration=$SLATE_DURATION[thumb3];
 [0:v][thumb1]overlay=100:100[tmp1];
 [tmp1][thumb2]overlay=690:100[tmp2];
 [tmp2][thumb3]overlay=1280:100[slate_raw];

 [slate_raw]
 drawtext=text='$HEADLINE':fontcolor=white:box=1:boxcolor=black@.6:
 boxborderw=10:fontsize=72:x=(w-text_w)/2:y=(h/2)-90+$MIDDLE_Y_NUDGE$FONT,
 drawtext=text='$TITLE':fontcolor=white:fontsize=48:
 x=(w-text_w)/2:y=(h/2)+$MIDDLE_Y_NUDGE$FONT,
 drawtext=text='$CLIENT':fontcolor=white:fontsize=48:
 x=(w-text_w)/2:y=(h/2)+60+$MIDDLE_Y_NUDGE$FONT,
 drawtext=text='$CONTACT':fontcolor=gray:fontsize=36:
 x=(w-text_w)/2:y=(h-(230+$BOTTOM_Y_NUDGE))$FONT,
 drawtext=text='Pix Ref\: $PIX_REF':expansion=normal:fontcolor=gray:
 fontsize=36:x=(w-text_w)/2:y=(h-(180+$BOTTOM_Y_NUDGE))$FONT[slate];

 [4:v]scale=1920:1080:force_original_aspect_ratio=decrease,
 pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black, setsar=1:1[v1];
 [4:a]aresample=48000,aformat=sample_fmts=s32:channel_layouts=stereo[a1];

 [slate][5:a][v1][a1]concat=n=2:v=1:a=1[vcat][acat];
 [vcat]drawtext=text='$MESSAGE':fontcolor=$MESSAGE_COLOR:box=1:boxcolor=black:
 boxborderw=10:fontsize=42:x=(w-text_w)/2:
 y=h-(100+$BOTTOM_Y_NUDGE):fontfile=$FONT[outv]
 " \
 -map "[outv]" -map "[acat]" \
 -c:v libx264 -pix_fmt yuv420p -c:a pcm_s24le -movflags +faststart $OUTPUT_LENGTH_ARG "$OUTPUT_FILE"

Pro Tools Markers from Resolve CSV Markers

Thu, 06 Nov 2025 19:49:39 -0800

Just a little sketch of this; it’s very easy to whip something like this up in a few minutes with py-ptsl.

import csv
import sys, re

import ptsl
from ptsl import PTSL_pb2 as pt


def create_marker(client: ptsl.Client, time: str, notes: str):
 print("Time: {}\n\t{}".format(time, notes))

 result = client.run_command(pt.CId_CreateMemoryLocation, {
 'name': notes[0:32],
 'start_time': time,
 'end_time': time,
 'time_properties': 'TProperties_Marker',
 'reference': 'MLReference_Absolute',
 'comments': notes,
 'color_index': 7,
 'location': 'MarkerLocation_NamedRuler',
 'track_name': 'Robert Notes'
 })

 print(result)

def main():
 client = ptsl.Client(company_name="Squad 51",
 application_name='csv_import')
 for p in sys.argv[1:]:
 with open(p, "r") as f:
 table = csv.DictReader(f)
 for row in table:
 time = row['Record In']
 notes = row['Notes'].strip()
 if md := re.match(r'^Marker \d+ - (.*)$', notes):
 notes = md.group(1)

 create_marker(client, time, notes)

 client.close()


if __name__ == "__main__":
 main()

UCSINFER for Renaming Sounds

Sat, 30 Aug 2025 21:23:54 -0700

After goofing around a bit with the ucsinfer gather and evaluate I’ve built out the recommend feature a bit.

Note 9/6/2025: This article was written around the time ucsinfer was at commit 1a42d7d9. There have been signififcant changes to the codebase since that time, including enhancements to the recommend feature, but it should still mostly work the way depicted here. Check the online documentation for all the latest updates.

Category inference experiments with UCSINFER

Mon, 25 Aug 2025 14:24:06 -0700

I’ve had some success auto-categorizing sounds into their corresponding UCS categories by using an LLM and the technique of sentence embedding. I’m writing up my process here and hope people find it useful and can maybe take this forward to do other things.

This is also my first post to the “Notebook” and am testing the posting system.

How I Learned What ChatGPT Can’t Do

One of my original experiments with ChatGPT was to try to use it to automatically select a UCS category for a given text description. This seemed like exactly the kind of problem ChatGPT should be able to solve well: it knows that a Ford is a car, that explosions go bang and may invovlve gasoline or black powder, inferring a category given the text description should be easy.