The two words in the title name two different measurements. A buyer who treats them as one buys the wrong system. Frame rate counts how many composed pictures the screen draws each second. Latency counts how old the picture on the screen is right now, measured from the light that made it. A surround view can run a smooth high frame rate and still show the driver a view of where the kerb was a quarter-second ago. At a reversing crawl, a quarter-second is the distance a decision goes wrong.
The rest of the series pointed here whenever a number meant time. The overview called the processing local because a turning decision cannot wait on a link. The seam page leveled color in a published 0.26 milliseconds without saying where that sits. The mathematics page froze the whole projection into a lookup table without counting what filling it costs each frame. The heavy-vehicle page warned that a coach canvas runs at a lower frame rate on the same controller. Each of those is a clause in one budget, summed here for the first time against the wall clock a maneuver runs on.
The budget has a name the industry already uses: glass-to-glass, the time from the light striking the lens to the matching pixel lighting the screen. Every stage between those two pieces of glass spends some of it. The stages run in series, each waiting on the one before. The optimization work is the accounting that keeps the total under what a low-speed maneuver can tolerate, with the frame rate held high enough that motion reads smoothly. The two goals pull on different levers. The difference is the first thing to get straight.
Frame rate is throughput. Latency is age. They are not the same number.
A factory line makes the difference plain. A line that finishes one car a minute has a throughput of one car a minute, the headline number every visitor hears. A single car still takes hours to travel from bare frame to driveaway, the time it spends inside the building. Speeding up one station along the way raises neither figure much on its own. The two numbers answer two questions. A buyer who hears only the first has learned nothing about the second.
Frame rate is the throughput. Twenty-five composed pictures a second means a fresh bird eye view every forty milliseconds, the cadence at which motion on the screen looks continuous, clear of the flicker a low rate shows. It is set by the slowest single stage every frame must clear, the bottleneck of the pipeline. Widen that one stage and the frame rate rises with it, no matter how long or short the rest of the chain runs.
Latency is the age. It is the time one particular frame spends travelling the whole pipeline, lens to screen, the sum of every stage in series. The bottleneck alone set the frame rate. The age is all the stages added end to end. A pipeline built from many quick stages can post a high frame rate and a high latency together: each stage is fast, the queue through all of them is long. The screen updates often and shows an old world. The factory runs a car off the line every minute and still takes a morning to build each one.
The driver needs both clocks healthy for different reasons. A high frame rate keeps moving edges legible, a kerb sliding past the bumper drawn as a smooth slide. A low frame rate stutters, leaving the eye to assemble the motion. A low age keeps the drawn kerb where the real kerb is now: the wheel turned on the screen turns the tyre at the same instant in the world. One clock serves the reading, the other serves the trust. A system can hold one and lose the other.
The split decides which optimization helps. Work that widens the bottleneck buys frame rate. Work that shortens the chain or runs stages side by side buys latency. Some moves buy both, some trade one for the other. A few sold as speed lift the frame rate with the age left untouched. Each move below answers to both clocks, because the screen a driver trusts has to win on the second.
The whole delay is a sum of named stages that only makes sense added up in order. Light reaches the sensor and the exposure stage spends the first slice, the few milliseconds the sensor integrates light to build one frame, a slice that grows in the dark as the sensor holds the shutter open longer for a usable image, the reason the night page treats frame rate and latency as one of its own costs. The sensor reads the frame out next, commonly line by line in a rolling scan, adding close to one frame period between the top line and the bottom. The raw frame passes through the image signal processor for the debayer, the exposure and white balance the seam page’s color loop later harmonizes, the noise reduction the dark amplifies, each a fixed cost in the silicon. Next comes the stage four earlier pages were building toward: geometry. The mathematics page folded the entire fisheye correction and the ground projection into one lookup table. The trigonometry ran once at calibration and froze into that table, leaving the geometry stage a single textured read per output pixel, a memory sweep where a live solve would have been a maths storm every frame. The blend across the seams adds its weighted multiply. The photometric harmonization the seam page measured at a published 0.26 milliseconds takes its place beside it, a sub-millisecond line item the budget can almost round away next to the exposure and the display. The composed frame either drives the screen directly or detours through an encoder for the recorder. The encode is the trap: a frame compressed for storage can sit in an encoder’s buffer for several frame periods. A system that feeds the screen from the encoded stream pays the recorder’s latency on the driver’s display. Splitting the paths feeds the screen a short raw route and leaves the slower compressed route to the DVR alone. Transmission from camera to processor rides a serial link built for the job, the gigabit automotive cable that carries power, control and video on one coax with little delay of its own. The panel closes the budget, redrawing at its own refresh rate and adding up to one refresh period before the eye sees anything. Sum the named slices and the total lands in tens of milliseconds for a tuned system, with exposure, readout and display owning the bulk of it and the celebrated geometry stage, the hard part of the whole series, costing a single memory read. Optimization keeps that sum honest. The craft is knowing which slice is the fat one before reaching for a knife.
Latency on this screen is a distance. That is what lifts it from a comfort figure to a safety one. The bird eye view does its real work at the crawl: parking against a kerb, easing into a dock, threading a mirror past a gatepost. Picture the vehicle creeping at one metre a second, a slow walking pace. A frame a tenth of a second old shows the world ten centimetres back. At a quarter-second, the lag the opening named, the kerb on the screen sits a quarter-metre behind the kerb on the ground. The driver steers to the picture and meets the truth late.
The mirror-replacement world already put a number on how late is too late. Camera monitor systems that stand in for a legally required mirror answer to a published ceiling on end-to-end delay, set in the low hundreds of milliseconds, the figure the standards body fixed once the lag began to read as a hazard on a moving vehicle. A surround view at parking speed is a different device, a low-speed aid, no mandated mirror. The number does not bind it directly. It still marks the territory: a vehicle display that lags by more than a fraction of a second has crossed from aid into liability. That fraction sits in published ink, beyond a single designer’s opinion.
Speed sets the toll. The same lag that hides a quarter-metre at walking pace hides far less when the vehicle barely moves and far more the instant it does not. The surround view spends its working life at the low end, where the metres stay small. That is the design margin that lets the budget run to tens of milliseconds and still keep the screen honest. A highway speed through the same pipeline would smear the same lag into metres and demand a budget no commodity pipeline can hit. A system pushed to higher speeds, or trusted to inform a steering decision, spends that margin fast.
The frame rate carries its own safety weight at the corners. A pedestrian stepping into a blind spot is caught on the next frame. A slow rate is a longer gap with nobody drawn in it. Twenty-five frames a second leaves a forty-millisecond window between glances, ten frames a second leaves a hundred. The faster clock shortens the dark gap between updates, the slower clock lengthens it. At the bumper the difference reads as a person seen or a person seen late.
Two stages compete to be the bottleneck. The frame rate belongs to whichever runs slower. The first is the sensor. A camera cannot deliver frames faster than it gathers light. The exposure time sets a floor: in daylight that floor sits far below the target rate and never binds, in the dark it climbs as the sensor holds each frame longer, the moment the night page inherits where low light drags the rate down on its own.
The second is the fill. Composing one output frame means writing every pixel of the bird eye canvas, each pixel a fetch through the lookup table and a blend. The processor moves only so many pixels a second, its fill rate, the throughput of the imaging blocks the mathematics page placed the table in. Divide that fill rate by the pixels in one canvas and the result is the frame rate the geometry stage allows. At a twenty-five frame target the whole canvas has forty milliseconds to fill, every frame, with no overrun permitted. A small van canvas clears the window with room to spare. A large canvas eats it.
That division is the promise the heavy-vehicle page left unpaid. A coach canvas holds close to twice the rendered ground of a van’s. On the same processor at the same fill rate, twice the pixels halve the frames a second. The integrator buys the rate back one of three ways: a faster processor, a coarser output grid that draws fewer pixels, or a lower frame rate written onto the spec sheet. Resolution and rate trade against each other on one fill-rate budget, a dial the integrator turns once and the buyer lives with. Each setting is a number a buyer can ask for by name. The brochure photo that shows the same screen on both vehicles hides which one was chosen.
The four cameras set a quieter limit. The composite cannot finish until every camera feeding it has delivered its frame. The slowest camera in the set, or a camera that drops a frame under heat or a marginal cable, holds the whole picture back. A system waits for the straggler and loses rate, or composes on whatever frames arrived and mixes a fresh view with a stale one. That second choice is where the frame rate question hands over to synchronization, the subject two sections on.
The first move is the one this series already spent four pages making: precompute. The mathematics page froze the fisheye correction and the ground projection into a lookup table at calibration time. The runtime never solves geometry again. It reads an answer. Every heavy calculation that can be done once and stored is a calculation lifted out of the per-frame budget. The cost is rigidity: a frozen table holds only for the parameters it was built from. Any change to a lens profile or a camera pose forces a rebuild, the configuration event the regimes page logs. Precompute trades flexibility for speed, a trade that is nearly free on a fixed installation.
The second move is fixed-function silicon. The fetch, the warp, the blend and the colour correction run in dedicated imaging blocks built for those operations, the line-speed hardware the pipeline page located the work in, clear of the general processor’s instruction-by-instruction pace. A purpose-built block clears pixels many times faster than software on the same chip, at a fraction of the power, the reason a commodity controller can hold a frame rate at all. The cost is reach: a hardware block does the operation it was cast to do. An algorithm the silicon never anticipated falls back to slow software or waits for the next chip generation.
The third move is the resolution dial from the section above. Fewer output pixels fill faster. A system holds its frame rate by drawing a coarser grid, or holds its grid by accepting a lower rate. The honest version spends the budget where the eye is looking: the magnified action pane gets the pixels and the rate, the overview pane around it runs coarser, because a driver reversing onto a dock reads the rear segment and glances at the rest. The cost is the part of the canvas that went soft. The acceptance walk measures the asphalt at the apron edge, immune to which pane drew it coarse.
The fourth move is parallelism. Its cost is the subtlest of the four. Running the pipeline stages side by side, one frame in the sensor while the last frame is in the blender, lifts throughput toward the rate of the slowest single stage, the textbook win for frame rate. It does nothing for age. A frame still travels every stage in series from lens to screen. A deeply parallel pipeline can post a high frame rate and carry a high latency at once, the exact trap the opening named. Parallelism buys the throughput clock and leaves the age clock where it was. A spec that boasts frames a second has answered only half the question.
The four moves stack together, applied at once on a tuned system: the geometry precomputed, run in fixed-function blocks, the pixels spent where the eye looks, the stages pipelined for throughput. A final separate measurement of the age confirms the parallelism did not hide a long queue. Three of the four buy frame rate. Only shortening or reordering the chain itself buys back age, the lever the next sections test on the bench.
The seam page named one cause of a torn join: a raised object viewed from two camera positions projects to two ground spots, the parallax double that survives a perfect calibration. Time adds a second cause that has nothing to do with geometry. If the four cameras do not expose at the same instant, a moving object crosses the overlap at one place in the front camera’s frame and a slightly later place in the side camera’s. The composite stitches two moments into one picture. A cyclist passing the corner tears at the seam, halved or doubled, on a system whose geometry is faultless.
The cure is hardware synchronization, blunt in the published guidance: the cameras are triggered together, frame for frame, every composite built from light gathered in the same window. A shared trigger line or the serial link’s own timing holds the four shutters to one instant. Software that merely collects whatever frame each camera last sent cannot close the gap, because the frames were taken at different times and no amount of stitching invents the moment between them. Synchronization is a capture-side fact, set before the pixels ever reach the table.
Rolling shutter sharpens the demand. A sensor that reads line by line has already spread one frame’s own capture across a few milliseconds, top to bottom. Even a single camera smears a fast object. Two rolling sensors out of phase smear it in two directions at the seam. The faster the object and the closer to the join, the wider the tear. At parking speed the effect stays small, the margin the low-speed design leans on again, with fast cross-traffic the case that exposes a sloppy sync.
The count from the heavy-vehicle page raises the stakes. Four cameras hold four shutters to one instant; six cameras hold six, with the extra mid-flank seams each a new place a moving body can tear if the timing slips. More cameras mean more clocks to align, the synchronization budget growing with the camera budget. The acceptance check is a person walking the seams at a steady pace: a clean system keeps them whole through every handover, a system with loose timing splits them at the join the moment they move.
Latency is checked with a trick the standards bodies use and any workshop can copy. Point a camera at a running millisecond timer, a phone stopwatch will do. Arrange the surround screen in the same view, the lens taking in both the real timer and the timer as the system has redrawn it. Photograph the pair. The real timer reads one number, the screen reads an older one. The gap between them is the glass-to-glass delay in milliseconds, read straight off a single still. A few shots averaged smooth out the single-frame jitter. The same still shows whether the recorded path lags the live one.
Frame rate is the easier read. A logged frame counter, or a high-speed phone clip of the screen counting updates against its own timestamp, gives the frames a second directly. The two numbers want measuring separately, because the bench proves the warning the page opened with: a system can pass the frame-rate check and fail the age check, smooth and late at once. Both go in the report.
The numbers land where the rest of the series files its evidence. A tuned low-speed system reads in tens of milliseconds glass-to-glass, well inside the fraction of a second the mirror-replacement ceiling marks as the edge of safe, at a frame rate that holds motion smooth. A measurement that drifts toward that ceiling, or a frame rate that sags when the canvas is large, is a finding to raise before the vehicle ships, ahead of the day a driver reports the screen feeling slow and no part number explains why. The timer photograph is the cheapest evidence in the whole commissioning file. It settles an argument no brochure figure can.
Three lines carry the timing into a purchase document. The latency line states the glass-to-glass figure in milliseconds, measured by the timer method at the delivered resolution, with the live display path and the recorded path quoted separately where they differ. The frame rate line states the frames a second at the full canvas size the vehicle runs in service, the number the heavy-vehicle canvas can quietly erode and a small demo canvas can flatter. The synchronization line states that the cameras are hardware-triggered together and names the acceptance check, a walker crossing every seam without a tear.
The timing is the half of the product a showroom never shows, because a parked demo has nothing moving and nothing to be late for. It surfaces the first time a driver turns the wheel and the screen answers a beat behind, or a cyclist tears at a corner. Frame rate is how smooth the picture looks. Latency is whether it is still true. The order sheet asks for both in numbers. The bench confirms them before the keys change hands.
Frame rate is throughput, how many composed pictures the screen draws each second, set by the slowest single stage of the pipeline. Latency is age, how old the picture on the screen is right now, measured from the light that made it and summed across every stage in series. They are independent: a system can draw twenty-five smooth frames a second and still show a view a quarter-second old, the frames quick and the queue through the whole chain long. Frame rate is how smooth the picture looks, latency is whether it is still true. A buyer needs both quoted.
Glass-to-glass is the time from light striking the lens to the matching pixel lighting the screen, the sum of exposure, sensor readout, image processing, the geometry and blend, any encoding, transmission and the display refresh. A tuned low-speed surround view reads in tens of milliseconds. The mirror-replacement standards for camera monitor systems cap end-to-end delay in the low hundreds of milliseconds as a safety limit. A parking-speed surround view is a different device that the cap does not bind directly. That figure still marks the edge a vehicle display should stay well inside.
The displayed frame is older than the world by the whole pipeline delay. At a crawl that age becomes a distance: a quarter-second lag at walking pace puts the kerb on the screen a quarter-metre behind the real one. The common causes are a long encoder buffer feeding the screen from the recorded stream in place of a short live path, a large canvas filling slowly, a display refresh added at the end. Splitting the live and recorded paths, then measuring the delay on the bench, is what keeps the screen honest.
Yes. Composing one frame means filling every pixel of the bird eye canvas. A coach canvas holds close to twice the rendered ground of a van’s. On the same processor at the same fill rate, twice the pixels halve the frames a second. The integrator restores the rate with a faster processor, a coarser output grid, or a lower frame rate written onto the spec sheet. A buyer should ask for the frame rate at the full canvas the vehicle runs in service, the figure a small demonstration view quietly flatters.
Two causes meet at the seams. A raised object viewed from two camera positions projects to two ground spots, the parallax double that survives a perfect calibration. A moving object photographed by two cameras at slightly different instants lands at two places in time. The composite stitches the two moments into one torn picture. The second cause is cured by hardware synchronization, the four or six cameras triggered to expose together, frame for frame. A walker crossing every seam at acceptance proves the timing holds.
Point a camera at a running millisecond timer with the surround screen in the same frame, the lens taking in the real timer and the timer as the system has redrawn it. Photograph the pair: the real timer reads one number, the screen an older one, and the gap is the glass-to-glass delay. A few shots averaged remove the single-frame jitter, and the same still reveals whether the recorded path lags the live one. Frame rate reads off a logged counter or a high-speed clip of the screen. Both numbers belong in the commissioning file.
