In this post: Fixing a video preview that gets restarted and redrawn every time React redraws the page.
Key words: React, HTML video flicker, DOM redraw React, useMemo
First, an example of the problem:

(This is painful to look at. That’s why we’re going to fix it!)
This is a form that allows the user to upload a video and add a message. But every keystroke was causing the video preview to redraw!
Yikes indeed.
Originally, the <video> tag was part of the React component’s return, like this. On every state change (in this case, the contents of the text area changing), the whole DOM was getting redrawn, video and all.
return (
...
// lots of stuff omitted for brevity
...
{fileType === 'video' &&
<Row justify="center">
<video src={videoURL}
className="photo"
preload="auto"
controls
style={{height: '95%', width: '95%'}}
/>
</Row>
}
...
)
I started Googling things like “React video flickers when updating a form” and “React redraws video preview too often” and eventually landed on this helpful tutorial, Getting the heck out of React, which helped me understand the problem better, but the author’s examples were written for an older (2018) version of React and I got lost trying to adapt them to my project. (My React journey only began a few months ago and it seems a lot has changed since the “older” tutorials were written).
I knew there had to be something, but I couldn’t find it by describing my problem to Google, so I explained it to a friend who has more React experience and he pointed me at the useMemo hook, which the docs describe as follows:
Pass a “create” function and an array of dependencies.
reactjs.orguseMemo
will only recompute the memoized value when one of the dependencies has changed. This optimization helps to avoid expensive calculations on every render.
Okay, that sounded promising. But I still didn’t know how to use it, and the method signature example just exists in a vacuum.
const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);
The method signature sets it to the value of a const, but I didn’t know where to put this const or what to have it return, so I went looking for more examples of useMemo
.
This tutorial (written in April 2020) was fresh and full of examples. My key takeaways about useMemo
were:
useMemo
doesn’t have to return a function that takes parameters (maybe I’m just a newbie, but seeing the (a, b) in the signature made me think it was going to act like a .sort() callback)useMemo
can return JSX instead of a function (JSX being HTML created by JavaScript or TypeScript), which means it can also return React componentsuseMemo
has a dependency array likeuseEffect
, and it will run the function it’s attached to if something in that dependency array changes- If the dependency array is present but empty, it will compute once on page load and then never again (which isn’t what I want, since the video preview is meant to be set/updated by the user)
- If there is no dependency argument at all (no array), it will compute every render (which would defeat the purpose of useMemo, so I knew my use case would have to including something in the dependency array)
For my use case, I created a new const, renderVideo
, that uses useMemo
and placed it above the return (...)
but still within the component that makes up the page. The function called by useMemo
returns the markup (containing the <video />
tag) that should only redraw when selectedFile
changes. Then, where the <video />
markup used to be, I replaced it with a call to renderVideo
instead.
The code explains it best:
const renderVideo = useMemo(() => (
<Row justify="center">
<video src={getImageAsUrl()}
className="photo"
preload="auto"
controls
style={{height: '95%', width: '95%'}}
/>
</Row>
), [selectedFile])
return (
...
{fileType === 'video' &&
renderVideo
}
...
)
(Note: no parenthesis or curly brackets are needed around renderVideo
)
It was that simple!

I think I ran in circles for a little while on this one because:
- I didn’t know about
useMemo
, and once I did, - I didn’t realize
useMemo
could be used for just returning some boring old JSX (HTML markup, basically) that simply has to remain static until a state variable changes – no comparisons or logic calculations needed
Anyway, I hope this helps someone else fix a flickering video or avoid an expensive recalculation on every React redraw!
Additional notes
Notes and observations that didn’t fit elsewhere…
Note #1: the reference to the const can’t be wrapped in any other HTML tags
I had some initial trouble with this technique because I had additional HTML tags around renderVideo
. The call to the useMemo const has to be the only thing after the &&
.
For example, it does NOT work if you do this:
// bad idea, does not work!
{fileType === 'video' &&
<div className="videoStyling">
renderVideo
</div>
}
Note #2: Using this technique with a component. I later refactored the video preview stuff into its own component, which looks like this:
VideoPreview.tsx
import React from 'react';
import Row from 'shared/components/Row/Row';
interface IVideoPreview {
videoSrc: string
}
const VideoPreview: React.FC<IVideoPreview> = ({videoSrc}) => {
return (
<Row justify="center">
<video src={videoSrc}
className="photo"
preload="auto"
controls
style={{height: '95%', width: '95%'}}
/>
</Row>
)
}
export default VideoPreview;
I updated const renderVideo
to use my new <VideoPreview />
component instead:
const renderVideo = useMemo(() => (
<VideoPreview videoSrc={getImageAsUrl()}/>
), [selectedFile])