Archive for the ‘Workflow’ Category

Red Workflow Primer #1

This is basically a rundown of the entire end-to-end system, starting with the sensor and working its way into recording media and post workflow, focusing specifically on points that impact on directly on workflow. Why? Well, I started writing a post just about workflow itself, and I realized I’d need to discuss RAW, which requires discussing the fact that Red records RAW data, which requires discussing how the sensor works…. This post will provide background on all of this stuff. An upcoming post will go into some of the specifics of a Mac-based desktop workflow for Red footage (well, to the extent that I can be specific, not having the camera yet).

I’ve been over a lot of this previously in the blog, but the info is pretty spread out here (and even more difficult to piece together from reading posts on RedUser), and there’s much more information out there now about how everything works. Red is different from most other cameras people are familiar with, and I’m going to do a lot of comparing and contrasting along the way.

Ready? Here we go.

1. Capturing

Red has a single large bayer-pattern sensor.

OK, so what’s a bayer-pattern sensor? Most digital imaging systems use one of two methods of capturing images.

More is more?

The approach most common in professional and prosumer camcorders is to split red, green and blue through a prism, and record them onto three separate chips. This approach is beneficial, because it allows a camera to sample all three colors at every point in the image. However, there are also some serious drawbacks to this approach.

First, off, as a general rule, the less glass is in your optical path, the better; having a prism in your optical path can introduce certain types of artifacts. Second, it’s nearly impossible to make three chip systems with chips over a certain size; it’s just too hard to make prisms for them. Having a large sensor, of course, is essential if you want to get shallow depth of field, an essential creative tool. Finally, most of the best lenses in the world (for shooting narrative features, anyway) are designed to work with 35mm motion picture film cameras. A lens designed to project light onto a single film plane doesn’t work with a three-chip system. (Well, there are messy workarounds, but they’re beyond the scope of this post.)

Less is more.

Presumably for the reasons mentioned above, Red decided not to go with a three chip design. OK, but if you only have one chip, how do you record three colors? There are some exotic approaches like the Foveon X3, but by far the most common approach (used, for starters, by nearly every digital still photo camera on the market) is to use a technique patented by Dr. Bryce E. Bayer in in 1976: the bayer-pattern sensor.

A bayer-pattern sensor is a light-sensitive chip (obviously) with a red, green or blue color filter over each of its photosites (see the illustration at the link above; it’s much easier than trying to understand a written description). For any given photosite (a photosite is an individual light-sensitive element), the camera captures color data for one channel. (It’s slightly more complex than this, because the filters don’t actually eliminate all other wavelengths, but that explanation will do for our purposes.)

What you’re left with is a single channel of image data that, if you looked at it directly, would look like a grayscale image with a checkerboard pattern all over it at the pixel level. This is a RAW image.

2. Recording

Red has a fairly unique approach to recording, which has many implications for workflow.

Your data, RAW and uncut

One of the things that makes Red nearly unique among motion picture cameras is that it takes the RAW bayer data from the sensor (see above), compresses it (see below), and stores it still in its RAW form, a feature it shares with many higher-end digital photo cameras.

Sliming down

Shooting 4K, Red is capturing a RAW image with a resolution of 4096×2304 (actually, cameras can currently only capture 4096×2048, but Red is going to enable the full resolution in a downloadable firmware update). Red’s analog-to-digital conversion happens at 12 bits. If we multiply out 12 bits * 4096 * 2304, we find that every frame Red captures should take up 113,246,208 bits, or in slightly more convenient units, 13.5 MB. That means shooting at 24 frames a second, Red can generate 324 MB of data, every second.

What do you do with it all? Just to record it you’d need at least six hard drives in a RAID 0 array (probably more like 8-10). And even if those were 1 TB drives, the largest currently on the market, you’d still fill the entire 6 TB array with less than an hour of footage! While there are some situations where this kind of setup might be practical (and Red can work with it, sending uncompressed data out through an optional optical port), it’s not very practical for most shooting.

Red’s solution to this problem is REDCODE RAW, a compression algorithm designed specifically for the Red camera. The camera takes that 324 MB of data and applies about 12:1 compression, squeezing it down to around 27.5 MB/s — less data than uncompressed standard definition video.

RedCode RAW is a wavelet compression algorithm. In terms of image quality, this means it can deliver much better quality than what can generally be expected from the other major class of image compression algorithms, DCT algorithms. If you’ve ever seen a JPEG, watched MiniDV footage, or watched a DVD, you’ve seen an image compressed with a DCT algorithm. Wavelet algorithms have much less objectionable artifacts (no visible blocking, for instance). This comes at the cost of higher computational cost, but processors are fast enough now that this is no longer a problem.

Wavelet algorithms also have another property that makes them particularly interesting for Red’s application, which will be discussed in the post workflow section.

It’s a data world

Red records footage as files on compact flash cards. Later, it will be able to record directly to a disk-based digital magazine called the RED DRIVE, or to various other sorts of sold state memory.

The important point here with respect to workflow is that capturing footage through a deck (or using the camera as a deck) is, with Red, an obsolete notion. Footage isn’t captured in the typical sense; one simply attaches the recording media to a computer with a standard interface (the CF cards can be read in a normal CF reader, the RED DRIVE will connect over USB or FireWire), and copies footage files over like normal data files. This clearly has a huge number of benefits, which are so obvious there’s not much point in elaborating on them here.

3. Post Workflow

RAW diet

Anyone with experience shooting RAW on a digital SLR camera is aware of the benefits that feeding RAW data into your image processing pipeline can have. Sharpening, white balance, and a host of other parameters can be tweaked in the comfort of your office, looking at a nice big reference monitor, instead of being “burned in” when you shoot. Red shares all of these advantages, and even provides a bit more flexibility. For instance, since Red uses exclusively digital gain, you can actually choose your ASA after the fact (sort of; I’ll do a future post on this subject). Red’s software also allows the user to tweak the parameters of the algorithm (called a demosaic or debayering algorithm) which converts that bayer checkerboard pattern (see above) into a normal RGB image. Do you want a smoother image, or do you want the algorithm to extract more detail? You decide.

And, of course, none of the changes you make change the actual data in the original REDCODE files (which have the entertaining file extension ‘r3d’). They’re just stored as metadata (data about data), and can be discarded or modified at any time.

It’s also possible to decode the RAW data differently depending on whether one wants a higher quality image, or an image that can be decoded with less processor power (e.g. for real-time playback).

Catch the wavelet

Remember I said wavelets have another interesting property relevant to post workflow? Wavelets make it very easy to extract fractional resolutions. For instance, if you have a 4K wavelet-compressed image, and you want to extract a 1K image from it, this can be done with relatively little processing power — vastly less than decoding the entire 4K image and scaling it down.

Playing back 4K in real-time is something that isn’t possible on widely available computing hardware at the moment, and there’s not much point in it anyway, since almost nobody has hardware that can actually display a 4K image. This makes the fractional resolution decoding enabled by wavelet compression extremely useful, particularly combined with the ability to decode RAW at varying qualities (see above). Between these two factors, data suitable for almost any purpose — from an on-set rough edit, to outputting digital dailies, to a 4K final conform, can be extracted directly from the original REDCODE RAW data files.

And that’s a good place to stop for today, because the next subject, namely how that REDCODE data gets fed into an actual post pipeline and what one can do with it there, is sufficiently complex to merit is own fairly long post.

Red workflow possibilities #1

So, the first batch of cameras shipped out nearly three weeks ago now, and the second followed a week later. With 50 Red Ones in the wild now, information has come streaming in. This post is mostly based on what I’ve picked up on RedUser.net. We’re not getting our camera until November 30 and Red hasn’t (yet?) made its QuickTime codec and RAW processing software available to non-owners.

Red workflow is — as one might expect for a camera that has only been on the market for three weeks — still fairly immature. That said, at least five distinct workflow possibilities have emerged. These are:

  • Traditional DI finish
  • Native SCRATCH workflow
  • Desktop offline/online workflow
  • Desktop online native workflow
  • Desktop online non-native workflow

Traditional DI Finish

This one is fairly straightforward. After being downloaded, Red footage is simply processed into 2K or 4K DPX or TIFF sequences, and fed into precisely the same sort of DI pipeline used for DPX or TIFF sequences scanned from film. This will probably be the most common workflow, at least initially, for higher-end feature productions, because it’s extremely comfortable for them.

The one missing piece in this workflow right now seems to be that RedAlert (the stopgap application Red has given to camera owners to process RAW footage while the fully-fledged RedCine app is being finished) doesn’t currently transfer most of the metadata from REDCODE RAW files into DPX sequences. I’d expect this to be fixed soon. (If it hasn’t been already.)

This is Indie4K, though… the extremely high costs associated with this approach (a 100 minute feature with a 10:1 shooting ratio can be expected to take up dozens of terabytes) will probably make it mostly off-limits to low-budget indies.

Native SCRATCH

Assimilate has been on board with Red from the beginning — we saw them handing out cards and Red’s NYC NAB screening event last year. It’s not hard to see why. The two companies have fairly similar approaches to the market. They’re both new players in established markets, who have nothing to lose by offering products and prices that actually reflect the state of technology, rather than old market segmentation schemes.

Anyway, Assimilate now has native REDCODE RAW support in a beta version of its SCRATCH software. Though probably still out of the price range of many indies, this option is a lot cheaper than a traditional DI workflow, and brings all the benefits, well known to fans of dSLR photography, of working with original RAW footage.

Desktop Workflow

Since there are three possibilities here — and since they’re going to get discussed in more depth, being more relevant to the primary audience of this blog — desktop workflow options will get their own post, which should be up within the next few days.

Red & a Mac-based DI

Red makes many workflows possible, but as of right now, the most clearly defined one is the one that will be made possible by the REDCODE support in Final Cut Pro 6. This post will lay out how that’s going to work, to the best of my understanding. Like the post on REDCODE QuickTime support (which you should read before reading this post), this information was pieced together from many sources, and as a result some things are still unclear and others might not be completely accurate.

First off, it’s useful to be a bit more precise about exactly what level of support exists for REDCODE in Final Cut Pro.

All versions of Final Cut Pro will see REDCODE footage through QuickTime reference files (see QuickTime link above). You should be able to cut footage at 1K and 2K (more on 4K later) even in FCP 5.x. So, what’s the big deal with FCP 6? An updated version of FCP 6 (note: not 6.0, but an update that will come later) will add two important things to the mix.

The first of those is RT support. As folks familiar with FCP know, in order to get real-time features, a timeline has to be using a “blessed” codec — one which Apple explicitly supports for RT. In this FCP 6 update, REDCODE will be such a codec. Until that update ships, you’ll be able to play back and make straight-cut edits in FCP on a timeline that uses REDCODE, but anything more than than (transitions, filters, etc.) will require rendering.

The second big thing that will come in that FCP update is an FxPlug plug-in that brings many of the features of REDCINE right into Final Cut Pro. (For those unfamiliar with FxPlug, it’s Apple’s newish plug-in architecture for Final Cut Pro and Motion, which opens up many more possibilities than the previous plug-in mechanisms for FCP and allows for vastly higher performance.) This plug-in will allow for fine control over the “development” of RAW footage, and can actually share look files with both REDCINE and the camera (more on that in another post).

It’s unclear exactly what the implications of not having Red’s FxPlug will be. This is an important question for people looking to cut Red footage in FCP prior to the release of the update that adds explicit support. FCP will certainly still be useful for an offline edit (it was used like this on the Peter Jackson short, Crossing the Line), but will it be possible to get decent results for your final conform? Since the REDCODE codec will apparently be giving data in a full float color space to FCP, the data you’ll need to get your image to look the way you want it to should be in the image data presented to FCP, but will you be able to massage it to look the way it should without a tool designed for this task?

Another thing that’s presently unclear is whether Apple’s new Color app (previously Silicon Color’s Final Touch) will be able to work with footage directly from a REDCODE timeline. My guess is that it will, but that you’ll have to render a clip that has had its look tweaked with Red’s FxPlug (or probably any clip that has had any FCP filters applied to it), since Color doesn’t, as far as I’m aware, have support for FCP plug-ins.

What about 4K? Well, that’s a mixed bag. Some apps in Apple’s toolset support it with no problem, like Shake. FCP doesn’t officially support it, but can be coaxed into doing it. Color only supports 2K. Motion, I believe, technically supports 4K, but you have to have the right video card. As of right now, plan on finishing at 2K with this workflow. This is not, mind you, a major problem, as there’s almost no venue where 4K is actually beneficial at present (more on that in a future post).

Ultimately, based on the information I’m familiar with and a bit of speculation, here’s how I expect a typical Mac-based workflow for a Red feature to go, once the FCP 6 update with additional REDCODE support hits the streets:

  1. Shoot 4K REDCODE RAW.
  2. Download to a RAID attached to your editing system. (See many previous posts on storage.)
  3. Bring preview-quality footage at 1K or 2K into FCP via appropriate reference movies. (See previous post on QuickTime REDCODE support.)
  4. “Develop” as desired using Red’s FxPlug.
  5. Render VFX or CG shots out of Shake, Maya, etc. as REDCODE RGB at 2K and bring them into FCP timeline.
  6. Edit, with full RT support, etc.
  7. Re-link FCP project so it points to reference movies that specify full quality 2K footage. Change timeline resolution if it was previously 1K.
  8. Open clips from the timeline in Color, grade them, and render back to the FCP timeline.
  9. Output to desired format via Compressor or QuickTime conversion (much more on creating appropriate deliverables in future posts).

If this is accurate, it’s a fairly straightforward workflow, that should allow for 2K deliverables to be produced with a reasonably priced workstation and a fairly moderate amount of storage. That’s pretty impressive, given the speed of Red’s development program and the fact that they were also working on some other stuff (like, you know, the camera) at the same time. It’s interesting to see an upstart like Red coming out of the gate with a better post workflow than most major vendors do. (I didn’t see Sony shipping an HDV QuickTime component the day its first HDV cameras shipped.)

Anyway, this is basically the workflow we plan to use, so expect lots more details about it in the future.

QuickTime REDCODE support explained

If you’re shooting a feature with a Red camera, the obvious format choice is 4K REDCODE RAW at 24 fps. The question is, what next? The announcements Red and Apple made at NAB clarified a lot of this (even for people who aren’t using Final Cut), but not everything.

What do we know? Well, we’ve known for a long time that the camera would ship with REDCINE, a program for doing “one light” color correction and exporting footage to other formats. But working with 4K (or even 2K) uncompressed requires far too much storage for low-budget indies to reasonably manage, and there was never a really obvious choice for a high-quality compressed format. (Well, except, possibly, for CineForm, which I admit I don’t give the attention it deserves, since I’m Mac-based and CineForm was until recently Windows-only.)

The ideal case for low-budget indies is a fully-compressed workflow starting with native REDCODE support in commonly used applications. And the way to get that is through supporting REDCODE in QuickTime, which Red has been discussing for a long time. Until NAB, though, we didn’t really know how that would work. Now we know a lot more. And the news is good.

Actually editing online at 4K is presently unreasonable on commodity hardware, and there wouldn’t be much point, as you couldn’t monitor 4K anyway. At the same time, rendering out proxy files to edit, and then doing a conform process once editing is done, is a big hassle. Fortunately, there is a solution here. As I’ve discussed before, REDCODE is a wavelet codec, and one of the interesting properties of wavelet codecs is that they make it possible to extract fractional resolutions very efficiently. That is, if you have a 4K file, you can easily extract 2K, 1K or even .5K footage directly from it, without having to decode the full 4K data and then scale it down.

The question on a lot of people’s minds has been how you’d take advantage of this neat ability for QuickTime apps with no REDCODE-specific support.

We now know Red’s answer: reference movies.

What’s a reference movie? A reference movie is a tiny little QuickTime movie consisting of a pointer to a file containing REDCODE data, and instructions on how to decode it. If you’ve got some 4K REDCODE RAW data and you want to work with it in a QuickTime app at 2K, instead of loading that file into the app directly, you point the app at the appropriate reference movie, which will tell the REDCODE QuickTime component to extract 2K from the 4K file, and pass that to QuickTime. To get 1K data, you point the app at a reference movie that instructs the REDCODE codec to pass 1K data, and so on.

While this is a little less clear, I would expect reference movies will also be able to specify what quality image is to be passed, so if you’re just editing you can get the results of a wavelet fractional resolution decode (which is fast), or if you’re doing a final conform (at, say, 2K), you can get the results of decoding the full 4K and using a high-quality scaling algorithm to produce 2K (which is slower).

Another important piece of the workflow puzzle is the fact that the REDCODE QuickTime codec will support both REDCODE RAW and REDCODE RGB interchangeably. This is very important for a compressed workflow. Remember, you can’t output to REDCODE RAW on a computer. A RAW format encodes unprocessed sensor data, which isn’t at all like the pixel data that comes out of a rendering pipeline. What this means is, a compressed workflow starting with REDCODE RAW is going to necessarily need to mix RAW and non-RAW clips. The fact that Red is supporting both RGB and RAW variants seamlessly within what appears (to QuickTime) to be a single codec, is what enables this.

Finally, while REDCODE uses a 12-bit linear color space internally, different apps will work best with data presented in different color spaces. In Shake, for instance, you’ll probably want to bring in REDCODE data as 16-bit RGB. In Final Cut, in contrast, you’ll want to bring in 32-bit YCbCr (which is still 4:4:4 in FCP, by the way), because Final Cut doesn’t support RGB at anything above 8 bits. The REDCODE QuickTime codec will also accommodate these requirements, converting between color representations as appropriate. (Which isn’t nearly as problematic in these larger color spaces as it is in an 8-bit world.)

Where do these reference movies come from? They’ll be generated automatically by the camera, and they’ll be sitting on your digital magazine, along with your actual footage. I’d assume there will also be a desktop utility which you can point at a REDCODE file to generate an appropriate reference movie as well.

When you put all of this together (and assuming I’ve understood it all correctly; this is basically synthesized from a large number of posts over on RedUser.net), you get a solution which lets the large number of QuickTime apps out there work with REDCODE RAW and RGB data in a flexible, largely transparent way.

Up next: 2K and 4K workflows on the desktop.

Shooting Red for broadcast

So, Red is making an affordable camera that produces great footage. What do you do with it? Well, it depends what platform you’re on, what sort of content you’re working with, and what your budget is.

Information is still a little hazy on some workflow issues, so this is the first post in a series that will continue as more information comes out.

Everyone is focused on using Red for digital cinema, and certainly that’s the most exciting application of the camera This blog is, nominally, about digital cinema, and I’ll get to that soon. Odds are a lot of people are also going to be shooting broadcast material with the camera, and this has gotten somewhat less attention. So, let’s start there.

First off, for broadcast delivery, you might not want to shoot 4K RAW. Why do I say this? The two standards for HD broadcast are 720p60 and 1080i60 (or PAL-country equivalents). Shooting REDCODE RAW on-board at 4K, you can only go up to 30 frames a second.

For some material, like narrative work, it’s possible you’ll still want to shoot at 24 fps and add appropriate pulldown to conform to these standards. In that case, you’ll probably want to shoot 4K RAW. But for other sorts of material, you’ll probably want to shoot in a format which captures 60 or 50 frames a second, which means shooting at 1080p or 2K.

If that’s the case, your workflow becomes:

  1. Shoot 1080p60/1080p50 RGB (won’t be enabled when the camera first ships) or 2K RAW @ 60/50 fps.
  2. Process footage into Apple ProRes or Avid DNxHD 1080i or 720p through REDCINE. Or, if using Final Cut, through the new “Log & Transfer” interface. (The tapeless equivalent of “Log & Capture”.)
  3. Edit material online in ProRes or DNxHD.
  4. Go out through a Kona card or similar to the appropriate tape format, and hand that to your client.

If you’re going out to a tape format which uses a codec your editing environment has native support for (e.g. DVCPRO HD in Final Cut), you might want to change this a little, and convert directly to that format from REDCINE, and then output over FireWire. This results in a final product that has only been through two generations of compression (REDCODE and your delivery codec) rather than three (REDCODE, your editing codec, and your delivery codec).

What determines whether you should shoot 1080p RGB or 2K RAW? That’s a rather complicated subject that I’ll address in another post.

Up next: how do to a 2K (or possibly even 4K) DI on your desktop, and higher-end DI options.