# GOP Desk

> A cut you did not re-encode landed somewhere else. A stream is a sequence of groups, and
> only the I-frame at the head of each one can be decoded on its own - so a trim that copies
> starts at the nearest preceding keyframe, not where you asked, and can be out by
> (N-1)/fps.

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

## What it is

Five lanes over one encode - a rate, a keyframe interval, a B-frame run, open or closed, and
the cuts somebody asked for - plus a **free browser-side engine** that snaps every cut. The
engine costs nothing and needs no account. Writing the report costs credits.

## The arithmetic

    interval in seconds     N / fps
    landing frame           floor(frame / N) * N
    worst in-point error    (N - 1) / fps
    re-encode span          frame - preceding keyframe        worst: N - 1 frames
    reorder delay           b frames, where b is the B-run
    join cost, open group   b frames at every join
    join cost, closed       0

## Figures that are exact, and surprising

- A 250-frame interval at 25 fps is a keyframe every **10 seconds**. A cut asked for at
  **3.2 s lands at 0.0 s** - the whole request away - and the worst it could be is
  **9.96 seconds**.
- **Only one end of a trim moves.** An out-point needs no keyframe, because stopping is
  free. So a clip asked to be 44.3 s comes out **47.5 s**: longer by exactly the in-point's
  error, all of it at the head.
- **The re-encode span is worst just before a keyframe.** A cut at 3.2 s re-encodes 80
  frames; one at 9.9 s re-encodes 248 - almost a whole group - to move the in-point a
  similar amount.
- **The same setting is a different amount of time at every rate.** 250 frames is 10.42 s at
  24, 10 s at 25, 8.33 s at 30, 5 s at 50 and 4.17 s at 60. The number in the encoder does
  not move.
- **The order in the file is not the order on the screen.** With a B-run of 2,
  `I0 B1 B2 P3 B4 B5 P6` on screen is stored as `I0 P3 B1 B2 P6 B4 B5`, and the decoder
  holds **2 frames - 80 ms at 25 fps** - before it can output anything.
- **An open group has no clean boundary.** Its edge B-frames reference across the join, so
  b frames must be re-encoded at every cut. With no B-run stated that cost **cannot be
  computed**, and this page says so rather than reporting zero.
- **A scene change inside a group costs the frames after it.** A change 63 frames into a
  250-frame group leaves **187 frames** describing a difference from a picture that no
  longer resembles anything.

## The sheet

    ENCODE
    name     | the lecture capture
    fps      | 25                required; may be a fraction like 30000/1001
    gop      | 250               required, or give `seconds` instead
    bframes  | 2                 the run of consecutive B-frames; defaults to none
    closed   | open              open or closed; defaults to closed
    duration | 3600
    scene    | 12.5              the time of a scene change

    CUTS
    c1 | 3.2  | in  | the start of the answer
    c2 | 47.5 | out | where it ends

A cut row is `id | seconds | kind | description`, and the kind is `in` or `out`. **The two
are not symmetric**: an in-point can only be an I-frame and snaps backwards, an out-point can
be any frame and is exact.

If both `gop` and `seconds` are given and they disagree at this rate, the frame count wins -
that is what an encoder is actually configured with - and the disagreement is reported. A
cut whose kind does not parse is **refused rather than guessed**.

## Lanes

- `plan` - decide what the encode has to survive, before anything is captured
- `check` - where the cuts actually land (primary)
- `cut` - what a frame-exact cut would cost
- `order` - the order the frames are really in, and what a join costs
- `deliver` - as it is, fix on the next encode, or needs a re-encode

## What it cannot do

It is arithmetic on a stated structure and it **has not opened the file**. A real encoder
inserts keyframes on scene changes, so a stated interval is a **maximum rather than a
promise**: every error here is a worst case, and the only way to know the actual one for a
specific cut is to look. The B-pattern is modelled as a fixed run, while modern encoders vary
it and use hierarchical references, so the reorder distance here is a lower bound. And
nothing here knows what a particular tool does - some trimmers snap silently, some re-encode
without saying so, some do one and report the other.

## Links

- App: https://gop-desk.skillsafe.ai/
- API: https://gop-desk.skillsafe.ai/api.html
- Source skill: https://github.com/affaan-m/everything-claude-code (not affiliated or endorsed)