A logo drawn over the picture is gone from that frame — not from the clip. The pixels it covers were overwritten in every frame it appears in, so nothing can rebuild them from the frame they are missing from, and that is what makes the usual answer sound hopeless. But a logo sits on the same rectangle of the picture while the background keeps moving behind it, and the piece of background underneath was visible, unmarked, in other frames of the same shot. Carrying those pixels back is not a guess and it blurs nothing. On a 640x360 clip with a 100x40 corner logo and the background travelling 284 pixels behind it, the logo's own rectangle scored 4.07 dB against a clean copy as it stood, 27.55 dB after delogo, and 51.33 dB after borrowing from other frames — and nothing outside that rectangle was touched at all.
So there are three answers, not one. Hide it — delogo, blur, a flat box: cheap, always possible, always a guess. Crop it off: lossless, and the most expensive. Carry it back from the frames where it was not covered: the only one that puts real pixels there, and it needs one condition you can check in five seconds by watching the clip. Each of the three is measured below, including the shots where the third one cannot work at all.
Everything below is a run on this machine, on fixtures this repository builds. Both scripts that produce the numbers are named at the end.
These are different problems with different answers, and the wrong one wastes an afternoon. A logo you can see on every frame is in the pixels. A record naming the software, the camera or the account that produced the file is in the container, next to the video rather than inside it, and that one comes off without touching a single frame.
The test takes one command. A stream copy cannot reach inside compressed frames, so if the logo is in the picture, the copy is untouched:
ffmpeg -i marked.mp4 -c copy copy.mp4
marked.mp4 245153 bytes
copy.mp4 245153 bytes identical size, logo still on every frame
If instead you are looking at a container record, that command removes it as a side effect — which is a different page entirely. Removing the records a video carries →
The tool below does not remove a visible logo — nothing can, from the pixels underneath it. What it does is tell you which of the two you have: drop the file in and it lists the container records it finds, or says there are none. If it finds none, what you are looking at is in the pixels, and the rest of this page is about your options.
Every method below was run on the same two 72-frame clips, with the same 100x40 logo in the bottom-right corner, and compared against a clean copy of each. The two clips are the same content and the same encoder; the only difference is that in the second one the background travels 284 pixels behind the logo, which is 2.84 times the logo's own width. "Region" means the logo's own rectangle, measured on its own rather than averaged into the whole frame, because a whole-frame average is dominated by the pixels nobody touched and flatters every method equally.
| What you do | Region PSNR vs clean background still | Region PSNR vs clean background moving 284 px | What it costs |
|---|---|---|---|
| Do nothing — the logo stays | 4.33 dB | 4.07 dB | — |
Hide it — delogo, interpolated from the ring | 26.70 dB | 27.55 dB | a re-encode of every frame |
| Hide it — blur, smeared | 6.20 dB | 5.82 dB | a re-encode, and an obvious patch |
| Hide it — flat box, painted one colour | 15.58 dB | 16.29 dB | a re-encode, and the most conspicuous patch |
| Crop it off — deleted with the band it sits in | no score to give: the pixels are gone | 6.4x the logo's area, and the aspect ratio changes | |
| Carry it back from other frames — real pixels | impossible | 51.33 dB | a re-encode, and the logo has to move |
The middle of that table is not a ranking, and it is worth knowing why. "Do nothing" leaves a white plate in the rectangle; a flat box paints it black. Which of those two scores better against the original is decided by how bright the content underneath is and by nothing else — black wins where the content is darker than the midpoint between the two, white wins where it is lighter, and on this clip black wins. That is a statement about the clip, not about the methods. Blur and delogo are the same kind of number for a different reason: their score is a property of how much detail is under the mark, which is measured on a deliberately detailed fixture further down. The only row whose score does not move with the content is the last one.
For reference, the whole frame after delogo scores 45.58 dB against clean, up from 23.42 dB, and after carrying the pixels back 51.76 dB. Those are flattering numbers and they are not the ones to judge by: the logo's rectangle is 1.7% of the frame, and a whole-frame average is dominated by the pixels nobody touched.
Cropping is the only method that does not alter a single surviving pixel, which makes it the only one that does not soften the video. What it costs is frame area, and the cost is much larger than the logo, because a crop is rectangular:
| Crop | Pixels removed | Ratio to the logo | Result |
|---|---|---|---|
| the bottom 40 px | 640 x 40 = 25,600 | 6.4x | 640x360 (1.778:1) becomes 640x320 (2.000:1) |
| the right 100 px | 100 x 360 = 36,000 | 9.0x | 640x360 (1.778:1) becomes 540x360 (1.500:1) |
A 100x40 logo is 4,000 pixels. Removing it from the bottom costs 25,600, because the crop takes the entire 640-pixel-wide strip that the logo happens to sit in. Cropping the side is worse, at 36,000, because the strip is taller than the bottom one is wide.
The aspect ratio change is the part people forget. 16:9 is what every player, every phone and every embed expects. 2:1 is not, so the result is pillarboxed or letterboxed somewhere downstream, and the frame you carefully kept the middle of is now sitting inside black bars. If you crop, crop symmetrically or accept the bars.
One practical note in its favour: because cropping does not touch the surviving pixels, it is the one method you can combine with everything else. Crop what you can, and use delogo only on what is left.
delogo takes a rectangle and rebuilds what is inside it from the pixels just outside it. It never re-encodes the region specially; it produces a new frame, and the whole video is then encoded again. That is two separate costs, and they are worth separating:
region PSNR against the clean original the logo 4.33 dB after delogo 26.70 dB the part of the frame delogo never writes to after delogo vs the marked input 55.20 dB
The second number is the one nobody quotes. 55.20 dB is good, but it is not infinity, and it should be infinity: those pixels were never marked and delogo did not touch them. The difference is the re-encode. Every frame of your video is decoded and encoded again to fix one corner, and that is the price of admission for every method here except the crop. How much it costs depends on how busy the clip is and what quality you ask for — on a busier clip than this one the same comparison comes out lower — but it is never free.
It also means the box has to be right. Delogo samples a ring around the rectangle you give it, so the rectangle has to sit strictly inside the frame with room on every side. Give it a logo that is flush against the corner and it refuses outright:
delogo=x=540:y=320:w=100:h=40 Error: Logo area is outside of the frame.
Insetting the box by one pixel makes it run, and leaves a one-pixel outline of the logo in every frame — measured at 72 of 72 frames still showing it on a flat background, where a stray edge is obvious. This is the case where cropping genuinely wins: if the logo touches the edge, the strip it sits in has to go anyway.
Delogo is the best of the three hiding methods, and that makes it the fair comparison for the third answer. On a clip where the background moves behind the logo, delogo scores 27.55 dB on the region and carrying the pixels back from other frames scores 51.33 dB — same clip, same re-encode, same mark.
A delogo box covers where the logo was in one frame. If the logo moves, the box is correct for one frame out of seventy-two and wrong for the rest. On a black background — where the logo is the only bright thing, so counting bright frames counts the logo — this is not a matter of opinion:
frames still showing the logo nothing burned in (control) 0 / 72 logo travelling 72 / 72 logo travelling, after delogo 59 / 72
Fifty-nine out of seventy-two. The fixed box caught the frames where the logo happened to be passing through it and missed the rest. Handling a moving logo means knowing where it is in each frame, which is a detection problem rather than a filtering one, and it is why platforms that want their mark to stay put put it where it can be seen in every frame.
But look again at what that result actually says. A logo that moves relative to the background is a logo whose rectangle uncovers new picture every frame — and that is the exact condition the third answer needs. The thing that defeats a fixed box is the thing that makes the pixels recoverable.
A logo is fixed to the picture; the picture is not fixed to the logo. In anything shot with a moving camera — a handheld phone, a drone, a pan, or even a subject walking past a locked-off camera — the background slides behind the logo, and the rectangle the logo covers is a different piece of the world in every frame. Which means the piece of world hidden in frame 40 was sitting in plain sight in frame 20, and will be again in frame 60.
Finding it is a two-step job, and both steps are ordinary. First estimate how far the background moved between each pair of frames: a single global shift is enough for a pan, and on this fixture a one-dimensional column profile, matched over the rows the logo never covers, recovers the true shift to the pixel on all 72 frames. Then, for each frame, take the logo's rectangle and fill each pixel in it from whichever frames have that piece of background uncovered, averaging a handful of them.
Nothing is blurred, and nothing outside the rectangle is written: over the part of the frame the recovery never touches, the result differs from the input by 52.02 dB, which is the re-encode and nothing else.
The condition is the interesting part, and it is one sentence. A pixel under the logo needs exactly one other frame in which it is visible, so what the shot needs is not that every frame move far, but that the logo and the background move at least the logo's own width relative to each other across the clip. Measured at four speeds:
| How far the background travels | Relative to the logo's width | Share of the rectangle another frame can supply |
|---|---|---|
| 284 px | 2.84x | 100% |
| 142 px | 1.42x | 100% |
| 71 px | 0.71x | 71% |
| 0 px — camera locked, logo still | 0.00x | 0% |
Read the last row carefully, because it is the honest limit of the whole method. With the camera locked and the logo still, no other frame shows any of the covered background, so there is nothing to carry and the method has nothing to do — the same file and the same tool, and the outcome is decided by whether the logo and the background moved relative to each other during the shot.
Partial travel does not fail, it does less. At 71 pixels, 71% of the rectangle becomes real content and the rest is still a white plate — and a third of the rectangle left as a plate is a bigger error than a plausible guess over all of it, which is why borrowed pixels alone score 7.90 dB there against delogo's 27.62 dB. So the method as shipped is the combination: borrow where another frame has the pixels, interpolate where none does. That scores 31.93 dB against delogo's 27.62 dB on the same shot, and 51.33 dB against 27.55 dB when there is enough travel.
It is also the only row of the table above whose score does not depend on what happens to be under the logo. Measured on two very different backgrounds, delogo goes from 27.55 dB on a smooth photographic one to 9.24 dB on a highly detailed one, because interpolating a gradient is easy and inventing texture is not. The borrowed pixels score 51.33 dB and 37.80 dB on the same two, because they are not an approximation of the picture at all — they are the picture, from a different frame.
What it does not do: it needs relative motion, so a locked camera on a still scene has no answer, and a logo that travels with the scene — a sign on a wall, a logo on a shirt — never uncovers anything. Zoom, rotation and rolling shutter break the single global shift this fixture estimates, though not the idea. The borrowed pixels come from other frames of a compressed clip, so they are close to the original rather than equal to it. And the video still has to be re-encoded to write the result, exactly as for delogo.
Everything above assumes the logo is opaque. If it is semi-transparent — blended over the picture rather than painted on top of it — then the underlying pixels were not destroyed, only attenuated:
observed = alpha * logo + (1 - alpha) * original original = (observed - alpha * logo) / (1 - alpha)
The information is still in the file, scaled down. Inverting the blend recovers an approximation of it, and on a lossless fixture with a flat plate at 55% opacity it is measurable:
region PSNR, logo at 0.55 12.71 dB region PSNR, blend inverted 24.40 dB gain +11.69 dB
Eleven point seven decibels, and it comes with three conditions that are easy to state and hard to meet. The first is that the overlay has to be uniform and known: the recovery needs its opacity and its colour, and a two-tone logo needs the logo image itself rather than one number. The second is that the division amplifies whatever error is already in the sample — by 2.23x in luma here, and by 22.7x in chroma, because the overlay destroyed most of the colour and there is very little left to divide. The third is precision:
| Slope used | Region PSNR | Gain over doing nothing |
|---|---|---|
| 0.2985 (off by -0.15) | 11.61 dB | -1.10 dB |
| 0.3985 (off by -0.05) | 20.93 dB | +8.23 dB |
| 0.4485 (the measured value) | 24.40 dB | +11.69 dB |
| 0.4985 (off by +0.05) | 22.10 dB | +9.40 dB |
| 0.5985 (off by +0.15) | 17.12 dB | +4.42 dB |
Being wrong by a twentieth of the opacity costs two and a half decibels, and being wrong by a sixth of it costs more than the whole gain. There is no such table for an opaque logo, because there is no parameter to estimate: those pixels are simply gone.
One more caveat, and it is about the fixture rather than the method. The overlay used here is ffmpeg's drawbox, and measuring it rather than assuming it turned out to matter: its luma follows the alpha exactly, but its chroma does not — a saturated blue at U=240 comes back at U=132, where a plain blend predicts 178. So the two fitted lines above are measured through this pipeline, not derived from the alpha, and a real watermark's parameters would have to be measured from the file you actually have.
Every number on this page comes from two scripts, both of which build their own fixtures and write their own report. Run them and you get the same numbers on your machine:
# the hiding methods, the crop cost, and the semi-transparent case python dev/video_logo_methods.py -> dev/video-test/logo-report.txt # carrying the pixels back from other frames, and the shot where it cannot python dev/video_motion_recovery.py -> dev/video-test/motion-report.txt
The two commands worth having in your own hands are the crop and the delogo, since between them they cover most real cases. Set the box to your logo and the frame size to your video:
# crop the strip off — lossless, changes the aspect ratio ffmpeg -i marked.mp4 -vf "crop=iw:ih-40:0:0" -c:v libx264 -crf 18 cropped.mp4 # interpolate over it — keeps the frame, re-encodes everything ffmpeg -i marked.mp4 -vf "delogo=x=520:y=310:w=100:h=40" -c:v libx264 -crf 18 cleaned.mp4
If you want to know how much the re-encode cost you, compare the part of the frame nobody touched:
ffmpeg -i cleaned.mp4 -i marked.mp4 -lavfi "[0]crop=640:260:0:0[a];[1]crop=640:260:0:0[b];[a][b]psnr" -f null -
That is the 55.20 dB figure above. Anything much below 40 dB means the re-encode is doing visible damage, and the answer is to raise the quality rather than to add another filter.
And the condition for the third answer is not something you have to measure. Play the clip and watch a fixed feature near the logo — a sign, a window, the edge of a building. If it slides across the logo's rectangle during the shot, the pixels are there to be had. If nothing ever moves relative to the logo, they are not, and no tool changes that. Which layer a video watermark lives in, and which one comes off →
Only by cropping. Cropping cuts pixels away without touching the ones that remain, so what is left is exactly as sharp as it was. Every other method has to change the pixels, which means decoding and re-encoding the video. Measured here, a stream copy of the marked file is 245,153 bytes before and after with the logo untouched, because a copy cannot reach inside the compressed frames. So the choice is between losing a strip of the frame and re-encoding the whole thing.
It has delogo, and it does not remove the logo so much as interpolate over it. The filter reads the ring of pixels around the box you give it and fills the box in from them, so what comes back is a plausible continuation of the surroundings rather than the picture that was underneath. Measured on a 100x40 corner logo, the region scored 4.07 dB against a clean copy before and 27.55 dB after — and 51.33 dB when the same rectangle was filled from other frames of the same shot, in which the background moves behind the logo. Delogo is the best of the methods that guess, and it is still a guess.
Three candidates, and the choice is between their costs. Crop if the logo is near an edge and you can lose a strip: it keeps the remaining pixels lossless, but on a 640x360 frame a 100x40 corner logo costs a 25,600-pixel band, 6.4 times the logo's own area, and changes the aspect ratio from 16:9 to 2:1. Delogo if the frame size has to stay: it keeps the frame and the aspect ratio, but the patch is interpolated and the whole video is re-encoded to pay for it. Carry the pixels back from other frames if the logo moves relative to the background: it is the only one that puts real pixels in the rectangle, it scored 51.33 dB against delogo's 27.55 dB on the same clip, and it needs at least the logo's own width of relative travel across the shot. Where there is not enough travel, borrow what you can and let delogo fill the rest.
Because there is nothing underneath to restore, in that frame. A logo is drawn over the picture, so those pixels were overwritten and their original values are not in the frame they are missing from. Delogo can only build a new value from the surrounding ring, which works well on flat areas and badly on detail, texture and edges — measured at 27.55 dB on a smooth photographic background and 9.24 dB on a highly detailed one. It is the same reason a healed patch in an image editor is invisible on a wall and obvious on a face.
A fixed delogo box will not do it, and this is measurable. On a black background, where the logo is the only bright thing in any frame, a logo travelling across the frame is present in 72 of 72 frames before processing and still present in 59 of 72 after a fixed box was applied. The box covers where the logo was in one frame, not where it goes. But a moving logo is exactly the case where the pixels can be carried back from other frames, because its rectangle uncovers new picture every frame; it is a logo that never moves relative to the background that leaves no answer at all.
Not by hiding the region, no — delogo, blur and a flat box all work by replacing the pixels with something that was not there. But there is a way that blurs nothing: if the logo moves relative to the background, the pixels under it were visible in other frames of the same shot and can be copied back. Only the logo's own rectangle is written and every pixel outside it is passed through untouched — measured over the part of the frame the method never touches, the result differs from the input by 52.02 dB, which is the re-encode alone. It needs at least the logo's own width of relative travel across the clip; a locked camera on a still scene has no answer.
Yes, if you are willing to use ffmpeg, which is free and does all of this locally. Cropping is one crop filter, and delogo is one delogo filter; both are one-line commands and neither needs an account. What a free web tool adds is not a better method, it is convenience, and usually an upload. Since the file has to be decoded and re-encoded either way, the arithmetic is the same wherever it runs.