# Field Desk

> A field is not half a frame. It is a different moment. So a processing step that
> resamples across lines averages the two moments in every frame into one picture, and
> nothing downstream can take apart what has already been averaged.

https://field-desk.skillsafe.ai/

## What it is

Five lanes over one piece of footage and the chain of steps about to run on it, plus a
**free browser-side engine** that walks the chain. The engine costs nothing, needs no
account, and makes no network calls. Writing the report costs credits.

## The arithmetic

    moments a second   frames a second x 2          <- for interlaced material
    field period       1 / moments a second
    comb width         pixels per second / moments per second
    vertical detail    height on static, height/2 on motion
    reversed order     back one comb width, then forward three

## Figures that are exact, and surprising

- **An interlaced frame holds two moments, not half a picture each.** At 1080i25 the camera
  sampled **50 moments a second, 20 ms apart**, and the file reports 25 frames. Half of what
  was captured is invisible to anything counting frames.
- **The comb is a distance, not an artefact.** A subject crossing a 1920-pixel frame in two
  seconds moves **19.2 pixels** in one field period. Those 19.2 pixels are the teeth. Twice
  the speed is exactly twice the comb.
- **Interlacing halves the resolution only on what moves**: 1080 lines of detail on anything
  static, 540 on anything moving. That is why a locked-off shot passes every check that the
  pan two minutes later fails — and why a pipeline tested on a still frame has not been
  tested.
- **A scale before a deinterlace is unrecoverable.** It reads the frame as one picture and
  resamples across lines 20 ms apart, so every output line is a blend of both moments. The
  comb becomes a smear that is part of the picture. **Scale then deinterlace and the footage
  is gone; deinterlace then scale and it costs nothing** — same operations, same footage.
- **No deinterlacer keeps both the lines and the moments.** `bob` and `yadif2` keep all 50
  moments and invent 540 of every frame's 1080 lines. `yadif` and `linear` keep the lines and
  throw away 25 of the 50 moments. `blend` keeps both counts and averages them together.
- **`weave` is not a deinterlacer.** It keeps every line and every moment by leaving them
  interleaved, which is the state the material arrived in. What it preserves is the comb.
- **Reading the field order backwards is not a judder.** The subject goes **back 19.2 pixels
  and then forward 57.6** — three times the comb — fifty times a second. It still arrives in
  the right place at the end of every frame, which is why scrubbing looks correct and playing
  does not, and why this gets reported as a frame-rate problem.
- **An odd vertical crop flips the field parity.** Cropping by an odd number of lines moves
  every field onto the opposite parity, so the field-order flag that was true of the tape is
  false below that step. A deinterlacer stating the source's true order is then wrong — and,
  less intuitively, one stating the opposite is right.
- **4:2:0 chroma was already averaged across time.** One colour sample is shared between two
  lines that are 20 ms apart, before any filter runs. A perfect deinterlace of the luma cannot
  undo it, which is why deinterlaced colour fringes on fast movement.
- **Progressive segmented frame material cannot comb.** Two fields per frame, both from the
  same instant, carried in an interlaced container. Anything reading only the container flag
  deinterlaces it and spends 540 lines fixing a problem that does not exist.

## The sheet

    SOURCE
    name     | the 2011 conference tape
    width    | 1920
    height   | 1080
    fps      | 25
    scan     | interlaced
    order    | tff
    chroma   | yuv420p
    motion   | 960
    duration | 3600

    CHAIN
    s1 | scale       | 1280x720
    s2 | deinterlace | yadif
    s3 | encode      | h264 progressive 25

A chain row is `id | step | detail`, **in the order the steps run**. Steps: `deinterlace`,
`scale`, `crop`, `encode`, `concat`, `thumbnail`, `overlay`, `watermark`. Methods: `bob`,
`yadif`, `yadif2`, `weave`, `blend`, `linear`.

`width`, `height`, `fps` and `scan` are required. `fps` is FRAMES as the file reports them.
`motion` is pixels a second, and **there is no default for it** — without one there is no comb
figure at all, because a default would invent the number the whole page turns on.

## The lanes

- `plan` - decide the chain before the footage arrives
- `check` - what this chain does to this footage (the primary lane)
- `order` - which way round the two moments are
- `method` - what each deinterlacer keeps and what it spends
- `deliver` - what ships, what a reordering fixes free, and what needs the source again

## What it cannot do

It is arithmetic on declared settings and **has not seen a frame**. The motion figure is one
number standing in for a whole shot. The comb thresholds are working conventions rather than a
standard. The deinterlacers are modelled by what they trade, not by how good they are. And it
cannot tell you what the material actually is — a file flagged interlaced may be segmented
frame, or progressive with a wrong flag, or telecined film, and each wants a different chain.

## Source

Lanes derived from the `transloadit-media-processing` skill in
[github/awesome-copilot](https://github.com/github/awesome-copilot), about building multi-step
media pipelines on Transloadit: encode, resize, crop, concatenate, thumbnail, overlay. Every one
of those steps has an opinion about what a frame is. Not affiliated with or endorsed by the
authors of that repository, or by Transloadit.

## API

https://field-desk.skillsafe.ai/api.html