A sideways clip in a YouTube Live playlist is usually a mismatch between the clip’s rotation metadata and the way the playlist output is encoded or displayed. For a consistent result, inspect every source, apply the intended orientation to the decoded frames when needed, and test the actual output path rather than relying on YouTube to honour rotation metadata.
-c copy does not rotate video: it passes the encoded stream through without decoding frames, so it cannot apply a transpose filter. Metadata-only handling may work in a compatible chain, but FFmpeg’s documentation makes output metadata conditional on muxer support, and YouTube does not promise to apply every source file’s rotation metadata.
Identify which clips display in the wrong orientation
Start with what you can see, not with a filter copied from someone else’s command. Play each playlist item in a desktop player that displays it as intended, then compare that view with the live preview or a recording of the output. Note which files are sideways, upside down, or merely framed differently. A portrait clip with black bars is not necessarily rotated incorrectly; its visible content may be upright while its encoded frame is landscape.
Make a short inventory of the files and their expected presentation. For example, a playlist might contain landscape devotional footage, portrait phone recordings, and a clip that appears landscape in a file browser but rotates upright in a media player. Record the filename, what you expect the viewer to see, and what the current stream shows. This separates an orientation fault from a resolution, crop, or aspect-ratio issue.
Check transitions too. A playlist may appear correct for its first item and then show the next one sideways because the clips carry different display transforms. A single setting applied to the whole playlist is not necessarily suitable for every file. This is why streaming a playlist to YouTube Live with FFmpeg and H.264/AAC still requires checking how each source enters the output chain.
If the source files are not under your control, preserve copies before testing. Keep the original playlist and make a separate test playlist or output. That gives you a way to compare the encoded result against the source without losing the evidence of which item had which orientation.
Inspect rotation metadata and source dimensions
Use ffprobe on each source, or examine FFmpeg’s input log when it opens a file. Look for the video stream’s width and height and any display matrix or rotation information. A video can have landscape pixel dimensions while its metadata tells a player to display it rotated by a quarter turn. In that case, the displayed orientation and the stored frame dimensions do not tell the same story.
A starting inspection command is:
ffprobe -v error -select_streams v:0 \
-show_entries stream=index,codec_name,width,height:stream_side_data \
-of json clip.mp4
The exact fields reported depend on the file and FFmpeg build. If this does not show useful side data, inspect FFmpeg’s input log or use a media tool that can report the display matrix. Do not infer that a clip has no rotation just because a simple file-properties panel does not mention it.
FFmpeg documents -display_rotation as input per-stream metadata, expressed in degrees counter-clockwise before display. The option overrides existing display-transform metadata. That means the value you observe matters: applying a fixed 90-degree correction to every file may repair one clip and turn another the wrong way. The FFmpeg option documentation describes how this input setting interacts with autorotation.
Keep dimensions and orientation separate in your notes. A 1920 by 1080 frame and a 1080 by 1920 frame differ in geometry; a display transform can affect how a player presents either one. For a mixed playlist, decide on a target output geometry and presentation, then determine the required transform for each item against that target.
Understand FFmpeg autorotation behaviour
When FFmpeg transcodes video with autorotation enabled, it applies the rotation during filtering. In practical terms, FFmpeg decodes frames, transforms them, and then encodes the resulting picture. If autorotation is disabled or the video is not being transcoded, the rotation may instead be carried as output metadata, and only when the muxer supports it. This is not a guarantee that a live ingest service or every player will interpret that metadata.
The distinction is important for a playlist. Each input may have its own display matrix, so FFmpeg’s input handling can yield different presentation transforms as it moves from one file to another. A workflow that appears to preserve rotation for one source is not evidence that every item in a playlist will be presented the same way.
Stream copy skips video decoding and encoding. As a result it cannot apply transpose, hflip, vflip, or another video filter; it also does not make the source pixels physically upright. FFmpeg’s streamcopy documentation explains that copied streams bypass the filtering and encoding stages. The output container may also be unable to represent all information the source container held.
This does not make stream copy useless. If you have verified that the existing encoded frames and display information produce the desired result through the exact output chain, avoiding a video re-encode can save processing and avoid another lossy generation. But do not treat -c copy as a rotation repair, or assume YouTube will honour every source’s rotation metadata.
Choose between metadata handling and filtering
There are two broad approaches: retain a display transform as metadata, or bake the intended orientation into the encoded frames. Metadata handling can avoid re-encoding the video, but it depends on the output muxer and downstream player or ingest path preserving and applying the transform. FFmpeg’s documentation says metadata output depends on muxer support; it does not establish that a particular RTMP or YouTube Live path will honour it.
Baking rotation requires decoding and re-encoding video, but the resulting frames are already oriented as intended. The downstream system no longer needs to interpret a rotation tag to show that orientation. For a live playlist where viewers need consistent presentation across varied sources, this is generally the more dependable route, provided you test the actual output and accept the processing and quality trade-offs.
| Approach | What changes | Main trade-off | When it may fit |
|---|---|---|---|
| Stream copy with metadata retained | Encoded frames are passed through; display information may remain or be rewritten | No frame rotation occurs, and muxer or downstream support is uncertain | Only after testing the exact output chain and confirming orientation |
| Transcode with autorotation | FFmpeg applies the input transform during filtering | Video is re-encoded, so encoding settings and quality need attention | A source with reliable rotation metadata that should be baked into frames |
| Transcode with an explicit filter | You choose the transform per source or source group | You must inspect inputs and choose the correct filter; wrong settings worsen orientation | Mixed sources where you need a known, consistent presentation |
A bitstream-level option is not a blanket answer either. FFmpeg’s H.264 metadata filter documents display-orientation operations, but that is distinct from proving that the container, transport and YouTube playback will preserve and apply a transform. If you investigate that route, read the FFmpeg bitstream-filter documentation and test it end to end.
The practical decision is not “metadata or pixels in every case”; it is whether you can demonstrate that the metadata route survives your complete path. If not, transcode and verify the frames. When the ongoing pain is keeping a known video stream running without leaving a computer on overnight, StreamNeo removes that computer-running step, but you still need to prepare and validate the video orientation before using it.
Normalize mixed-orientation playlist clips
First choose what “consistent” means for your channel. You may want every clip to fill a landscape canvas, or you may want portrait material kept upright within a landscape frame with side padding. Those are different presentation choices. Pick a target frame size, aspect treatment, frame rate and audio policy before preparing the clips, so a portrait source does not unexpectedly change the output geometry at a playlist boundary.
Then work through each item. If its rotation metadata correctly describes the intended view, a transcode with autorotation enabled can apply that transform during filtering. If metadata is absent or wrong, correct the input interpretation or use a deliberate filter for that specific item. The appropriate filter depends on the actual transform and desired framing; inspect rather than presuming that every phone video needs the same 90-degree turn.
A simplified example of baking an inspected quarter-turn into frames is:
ffmpeg -i clip.mp4 -vf "transpose=clock" \
-c:v libx264 -pix_fmt yuv420p -c:a aac output.mp4
This is an illustration, not a universal command for a playlist. transpose=clock is appropriate only if the source needs a clockwise quarter-turn. A clip requiring the opposite direction needs a different transform; one that is already correct may need none. Scaling, padding, frame-rate handling, audio mapping and encoding settings must also match your output plan. Do not pair a video filter with -c:v copy: those choices conflict because copying does not decode frames for filtering.
You may be able to copy audio while transcoding video, but only when the audio codec and the chosen output container and ingest path are compatible. Otherwise encode the audio to a supported format. YouTube’s current Live encoder settings list RTMP/RTMPS and H.264, H.265/HEVC or AV1, with up to 60 fps, CBR, and a recommended two-second keyframe interval, with four seconds as the maximum. These are ingest settings, not rotation fixes; check the official page again before configuring a stream.
Prepare each clip so the encoded output has the geometry you chose. If your playlist method joins or switches between files, verify that it handles consistent stream parameters as expected. A source that has been rotated may need its width and height swapped before scaling or padding. Check both the orientation and the resulting frame dimensions rather than assuming a successful encode means a suitable output.
If using FFmpeg’s input -display_rotation option to set or override a transform, remember it is an input option and its interpretation affects the subsequent transcode. Test it with one representative source first. The playlist’s behaviour can depend on the FFmpeg version, source formats, playlist method, muxer and protocol, so avoid treating a command that worked on one clip as proof for the rest.
Test transcoded output before streaming
Inspect and play the actual transcoded files, not just the originals or FFmpeg’s command line. Re-run ffprobe to confirm the encoded dimensions and inspect for unexpected display-transform metadata. Open each output in a player that shows the decoded picture, and compare it with the source’s intended orientation. Look at the beginning and end of each file as well as a middle frame; an output can be technically upright yet cropped or padded in a way that cuts off important content.
Next test the playlist as a playlist. Watch every transition, particularly where a landscape clip follows a portrait one or where source dimensions differ. Check whether the video changes size, becomes stretched, is cropped, shows black bars, or turns sideways. Also listen for audio continuity and confirm that the end of one item does not interrupt or misalign the next. The issue you are solving is display consistency, but a useful test should catch the adjacent failures that would be visible in a real broadcast.
Use a short private or unlisted YouTube Live test before an event. YouTube advises testing with representative audio and video movement and monitoring stream health in its live-streaming tips. The playlist-resolution discussion is relevant here: orientation and dimensions are separate questions, but a changing frame geometry can make a playlist look inconsistent even when rotation is correct.
Keep a small record of the tested inputs, FFmpeg command or settings, output files and observed result. If a later source arrives from a different phone or editor, inspect it separately rather than assuming it shares the old transform. This is particularly useful for devotional or local-news loops assembled over time, where one portrait contribution can sit among many landscape clips.
Check the YouTube Live preview
Once the local output looks right, confirm the same result in the YouTube Live preview. Check that the video appears upright at the start, across a representative playlist transition and after the stream has been running for a while. Compare the preview with a recording or playback of the test stream if available. The preview and playback are the evidence for your exact path; a local media player alone cannot tell you how YouTube handled the incoming stream.
Watch stream health separately from orientation. YouTube’s encoder guidance discusses codec, bitrate, frame rate and keyframe interval, which affect delivery quality and stability rather than whether a frame is rotated. For example, its currently published guidance recommends 14 Mbps for H.264 at 1080p and 30 fps; that is a quality and connection setting, not an orientation remedy. Recheck the official settings page for current recommendations and choose settings your connection and encoder can sustain.
If the preview is still sideways, stop the test and narrow down where the mismatch enters. Check the transformed file first, then the playlist output, then the live preview. This sequence avoids changing several unrelated settings at once. If the local file is correct but the live preview is not, revisit the output muxer and metadata path, or use a verified transcode with orientation baked into frames. Do not infer that a successful connection means the visual output is correct.
For a continuous channel, also consider what happens when a device or process must stay on and a playlist needs monitoring. If your setup depends on a computer remaining available, how to keep a YouTube Live stream running when your computer is off covers that operational question. It does not replace the orientation test: whichever way you run the channel, validate the file and live preview first.
Before committing, compare the operating options on the pricing page. When the file and channel are ready, start free — 24-hour trial, no card.
FAQ
Does -c copy preserve video rotation?
Stream copy passes encoded video through without decoding frames, so it cannot apply a rotation filter. Display metadata may be retained or written only when the output muxer supports it, and that still does not guarantee that YouTube will honour it. Test the exact output path rather than treating copy as a rotation fix.
Should I use -autorotate for every playlist?
Autorotation is useful when the input metadata correctly describes the intended presentation and you are transcoding. FFmpeg applies the rotation during filtering in that case. Inspect clips individually, because a playlist can contain different transforms or incorrect metadata, and confirm that the output frames look right.
How do I know which transpose direction to use?
Use a test transcode on a clip whose intended orientation you can clearly identify, then inspect the resulting frames. The correct direction depends on the source’s actual display transform and desired output, so a fixed filter copied from another setup may turn a correct clip sideways. Include each distinct source type in your tests.
Will YouTube Live apply rotation metadata from my playlist?
The official guidance cited here does not guarantee that YouTube Live will preserve and apply rotation metadata from every source, playlist method, muxer or transport. If consistent orientation matters, transcode with the intended transform applied to frames and test the actual Live preview. Recheck YouTube’s current encoder guidance before the broadcast.