If this past summer had a theme, it was probably “The Summer I Learned to Use Final Cut Pro”. My bread-and-butter iOS consulting work took a backseat to several video-related projects, each of which involved a significant leap forward in my video-making skills. If I compare the video project from the beginning of the summer with the most recent one, I’d say the biggest difference is really learning how to use Final Cut Pro effectively. I don’t mean shortcuts or slick hidden tools, but really internalizing the underlying mental model of the software.
In software design, we talk a lot about responsibilities, composition, hierarchy and layers of abstraction. Final Cut’s model for transforming raw media into a final production is very similar.
The basic unit-of-media in Final Cut is the clip. A clip is some selection of underlying media, but it isn’t the physical on-disk media itself. This was the first realization I had. For C programmers it’s sort of like having a pointer to the same array, and only using parts of it in different places.
These clips can be combined into compound clips, which is really nothing more than two or more clips of media put together. To Final Cut these behave like normal clips and so there’s a sort of polymorphic model underlying the entire clip structure.
The big breakthrough this summer was understanding what things should be done to regular clips and what should be done to compound clips. Understanding this completely changed my workflow from a very linear, progressive approach to a more iterative one. Let me explain…
Here’s a screenshot from my latest guitar lesson Class Dismissed:
This project is a multi-camera performance of a song. The final composed video is in the upper right-hand pane. You can see the Six String Recess watermark, the live-action video and a title bar in the lower third.
At the top-level project, there are only two clips: the static watermark and the compound performance clip. The performance clip contains the lower-third titles, the multi-camera video with cuts and the sound clip.
If we open the compound clip we get this:
This clip has two responsibilities: the lower-thirds titles as well as the multicam cuts. The titles appear when the performance enters a new section of the song. It makes sense to put the titles and cuts together since the cuts end up being the superset of lower-thirds titles. That is, they change when the song section changes, and oftentimes more frequently.
If we drill into the video clip, we get this:
This clip is what Final Cut calls a multicam clip. It’s like specialized sub-class of compound clips in that it has the ability to support multiple camera angles. Final Cut offers a different user-interface for these kinds of clips that let you synchronize the clips and switch the active video and audio angles.
This would not be the right place for overlaid titles or watermarks. It breaks the encapsulation of this clip. The multicam clip is responsible for housing several clips in synchronization. That’s it. It doesn’t have the angle-cuts, that lives in the compound clip we looked at before.
You might wonder why the compound clip doesn’t have the watermark? The reason is that this performance was extracted from a separate project. This song performance is just a small three-minute section of a larger two-hour long guitar lesson. I originally cut the multicam angle and titles directly in the lesson project. That lesson was being sold and paying customers don’t need a big watermark on their paid-for products.
But I wanted to extract this out and put it on YouTube for free. As we all know “free” always comes with some strings attached and in this case it was the omnipresence of the Six String Recess logo.
Fortunately Final Cut made this easy by being able to select an existing set of clips from a project and convert them into a single compound clip. This was akin to refactoring some code to a common function via the Extract Method pattern. Now I had a single clip containing all of the fine-detail work of angle-cuts and titles in a single place that I could easily reference elsewhere.
The same nose-wrinkling odor of copy-and-paste applies to video production as much as it does to software. Creating the compound clip allowed me to duplicate the final product and still have a single underlying source. If I needed to change anything related to angle-cuts and titles, I had a single place to do it. Boom. The Single Responsibility pattern in action.
If you’re curious, there’s yet another layer to the multicam clip. Each individual video clip looks like this:
This is the most “atomic” clip there is in Final Cut. This media came right off the camera and the green audio track is the noisy audio from the camera’s built-in microphone. That audio only gets used when synchronizing the clips in the multicam clip.
Earlier I said that grokking this mental-model changed my workflow. The reason is that once I knew what responsibilities each clip had (or would have in the future) I could focus exclusively on executing tasks related to the level of resolution I was working at.
For example, when I worked on the camera-angle cuts I wasn’t worried about watermarks, transitions into or out of the performance or audio levels. Those were all things best dealt with outside of the compound clip.
The process is similar to slowly massaging code into a reasonable model. We don’t start out by putting everything in a single file and we also begin with an explosion of them either. You make a best guess, start working on the problem-space, learn and refactor along the way.
Final Cut makes it easy to leave TODOs for yourself throughout a project. I could worry about titles, transitions, even audio changes completely separately from the act of choosing clip lengths from the media library. Using this approach I could make entire passes through the project focused on specific aspects of the final production without having to context-switch between various concerns.
I don’t know if this is how the professionals do it or not. I only know that I have limited mental capacity for keeping track of tasks. In coding I’ve developed all sorts of tricks to break work down into bite-sized chunks. I can’t describe how satisfying it is to apply them to video-production.
Oh, and if you’re curious, here’s the final video: