videos: transcode can remove the audio stream (silent video) (#737)
Some checks are pending
CodeQL / Analyze (push) Waiting to run
Controller Tests / controller-tests (push) Waiting to run
Jest Tests / jest-tests (push) Waiting to run

A video's audio stream can be dropped the same way its video stream could
already be: a new REMOVE_AUDIO audio target maps only the video stream with
-an, needs a video container, and is refused for audio files.  Output
verification insists the result has no audio stream.

Removing both streams is refused by the validator, the API, resolve_output,
and the modal: choosing Remove for one stream resets the other to Keep and
withdraws the other's Remove option.

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
lrnselfreliance 2026-09-26 17:49:00 -06:00 • committed by Roland
parent 63ddad69e8
commit 15d3792b0e
No known key found for this signature in database
GPG key ID: 1BA620CE6C9A4680
7 changed files with 291 additions and 30 deletions

View file

@ -168,11 +168,14 @@ export const transcodeVideoCodecOptions = [
{value: 'h264', label: 'h264 (avc1)'},
{value: TRANSCODE_REMOVE_VIDEO, label: 'Remove video (audio only)'},
];
// REMOVE_AUDIO in modules/videos/transcode.py: drop the audio stream, the result is a silent video.
export const TRANSCODE_REMOVE_AUDIO = 'none';
export const transcodeAudioCodecOptions = [
{value: TRANSCODE_COPY, label: 'Keep (copy)'},
{value: 'aac', label: 'aac'},
{value: 'opus', label: 'opus'},
{value: 'mp3', label: 'mp3'},
{value: TRANSCODE_REMOVE_AUDIO, label: 'Remove audio (silent video)'},
];
// Containers for output with a video stream ...
export const transcodeContainerOptions = [

View file

@ -8,6 +8,7 @@ import {
import {
audioContainerForCodec,
TRANSCODE_COPY,
TRANSCODE_REMOVE_AUDIO,
TRANSCODE_REMOVE_VIDEO,
transcodeAudioCodecOptions,
transcodeAudioContainerOptions,
@ -68,6 +69,41 @@ export function containerFor({audioOutput, audioCodec, video}) {
return transcodeContainerOptions.some(i => i.value === current) ? current : 'mp4';
}
/**
* The video codec choices: Remove video is withdrawn once the audio is being removed (nothing
* would remain).
*/
export function videoCodecOptionsFor({removeAudio}) {
return removeAudio ? transcodeVideoCodecOptions.filter(i => i.value !== TRANSCODE_REMOVE_VIDEO)
: transcodeVideoCodecOptions;
}
/**
* The audio codec choices: Remove audio is only for a video whose video stream is kept; an audio
* file has nothing else, and removing the video already chose the audio as the result.
*/
export function audioCodecOptionsFor({audioOnly, removeVideo}) {
return (audioOnly || removeVideo) ? transcodeAudioCodecOptions.filter(i => i.value !== TRANSCODE_REMOVE_AUDIO)
: transcodeAudioCodecOptions;
}
/**
* The codec pair after one select changes. Both streams can never be removed (nothing would
* remain): choosing Remove for one stream puts the other back to Keep.
*/
export function chooseCodecs({videoCodec, audioCodec}, {video, audio}) {
let nextVideo = video !== undefined ? (video || TRANSCODE_COPY) : videoCodec;
let nextAudio = audio !== undefined ? (audio || TRANSCODE_COPY) : audioCodec;
if (nextVideo === TRANSCODE_REMOVE_VIDEO && nextAudio === TRANSCODE_REMOVE_AUDIO) {
if (video !== undefined) {
nextAudio = TRANSCODE_COPY;
} else {
nextVideo = TRANSCODE_COPY;
}
}
return {videoCodec: nextVideo, audioCodec: nextAudio};
}
const statusKind = (status) => {
if (status === 'complete') return 'complete';
if (status === 'running') return 'active';
@ -214,6 +250,7 @@ export function TranscodeModal({
const current = currentCodecs(video);
const removeVideo = videoCodec === TRANSCODE_REMOVE_VIDEO;
const removeAudio = !audioOnly && !removeVideo && audioCodec === TRANSCODE_REMOVE_AUDIO;
// An audio file has no video stream to keep or remove; removing the video makes an audio file.
const audioOutput = audioOnly || removeVideo;
@ -250,18 +287,20 @@ export function TranscodeModal({
};
}, [open]);
const changeVideoCodec = (value) => {
const next = value || TRANSCODE_COPY;
setVideoCodec(next);
setContainer(containerFor({audioOutput: audioOnly || next === TRANSCODE_REMOVE_VIDEO, audioCodec, video}));
};
const changeAudioCodec = (value) => {
const next = value || TRANSCODE_COPY;
setAudioCodec(next);
setContainer(containerFor({audioOutput, audioCodec: next, video}));
// `chooseCodecs` keeps Remove video and Remove audio from ever being chosen together; the
// other select also withdraws its Remove option (see `videoCodecOptionsFor`/`audioCodecOptionsFor`).
const applyCodecs = (change) => {
const next = chooseCodecs({videoCodec, audioCodec}, change);
setVideoCodec(next.videoCodec);
setAudioCodec(next.audioCodec);
setContainer(containerFor({
audioOutput: audioOnly || next.videoCodec === TRANSCODE_REMOVE_VIDEO, audioCodec: next.audioCodec, video,
}));
};
const changeVideoCodec = (value) => applyCodecs({video: value});
const changeAudioCodec = (value) => applyCodecs({audio: value});
const remuxOnly = !removeVideo && videoCodec === TRANSCODE_COPY && audioCodec === TRANSCODE_COPY;
const remuxOnly = !removeVideo && !removeAudio && videoCodec === TRANSCODE_COPY && audioCodec === TRANSCODE_COPY;
const sameContainer = container === currentContainer(video);
const containerOptions = audioOutput ? transcodeAudioContainerOptions : transcodeContainerOptions;
// Fragments are an mp4 concept (m4a is an mp4).
@ -272,7 +311,8 @@ export function TranscodeModal({
try {
const id = await transcodeVideo(fileGroupId, {
video_codec: videoCodec === TRANSCODE_COPY ? null : videoCodec,
audio_codec: audioCodec === TRANSCODE_COPY ? null : audioCodec,
audio_codec: audioCodec === TRANSCODE_COPY || (removeVideo && audioCodec === TRANSCODE_REMOVE_AUDIO)
? null : audioCodec,
container,
fragmented: canFragment && fragmented,
});
@ -292,6 +332,9 @@ export function TranscodeModal({
if (defaultsLoaded && removeVideo) {
hint = `The video stream is removed; the result is an audio file (.${container}). `
+ (audioCodec === TRANSCODE_COPY ? 'The audio is copied without re-encoding.' : `The audio is converted to ${audioCodec}.`);
} else if (defaultsLoaded && removeAudio) {
hint = `The audio stream is removed; the result is a silent video (.${container}). `
+ (videoCodec === TRANSCODE_COPY ? 'The video is copied without re-encoding.' : `The video is converted to ${videoCodec}.`);
} else if (defaultsLoaded && remuxOnly) {
const kept = audioOnly ? 'The audio is kept' : 'Both streams are kept';
if (sameContainer && canFragment && fragmented) {
@ -303,7 +346,7 @@ export function TranscodeModal({
hint = `${kept}: only the container changes to ${container} (a quick remux, no quality loss).`;
}
}
const buttonLabel = removeVideo ? 'Extract Audio' : remuxOnly ? 'Remux' : 'Transcode';
const buttonLabel = removeVideo ? 'Extract Audio' : removeAudio ? 'Remove Audio' : remuxOnly ? 'Remux' : 'Transcode';
return <Modal open={open} onClose={onClose} size='small'>
<Modal.Header>{audioOnly ? 'Transcode Audio' : 'Transcode Video'}</Modal.Header>
@ -319,7 +362,7 @@ export function TranscodeModal({
{!showJob && <>
{!audioOnly && <Select
label='Video codec'
data={transcodeVideoCodecOptions}
data={videoCodecOptionsFor({removeAudio})}
value={videoCodec}
onChange={changeVideoCodec}
disabled={!defaultsLoaded}
@ -327,7 +370,7 @@ export function TranscodeModal({
/>}
<Select
label='Audio codec'
data={transcodeAudioCodecOptions}
data={audioCodecOptionsFor({audioOnly, removeVideo})}
value={audioCodec}
onChange={changeAudioCodec}
disabled={!defaultsLoaded}

View file

@ -2,11 +2,11 @@ import React from 'react';
import {act, fireEvent, screen, waitFor} from '@testing-library/react';
import {renderWithProviders} from '../test-utils';
import {
containerFor, currentCodecs, currentContainer, EditVideoModal, JobProgress, preferredTarget, TranscodeModal,
useJob, VideoEditMenu,
audioCodecOptionsFor, chooseCodecs, containerFor, currentCodecs, currentContainer, EditVideoModal, JobProgress, preferredTarget,
TranscodeModal, useJob, VideoEditMenu, videoCodecOptionsFor,
} from './VideoEditMenu';
import {
audioContainerForCodec, TRANSCODE_COPY, TRANSCODE_REMOVE_VIDEO, transcodeAudioCodecOptions,
audioContainerForCodec, TRANSCODE_COPY, TRANSCODE_REMOVE_AUDIO, TRANSCODE_REMOVE_VIDEO, transcodeAudioCodecOptions,
transcodeVideoCodecOptions,
} from './Vars';
@ -221,6 +221,35 @@ describe('TranscodeModal', () => {
// Selecting it is exercised through containerFor (Mantine's dropdown is not driveable in jsdom).
});
test('the Remove audio option is offered for videos, not audio files, and never with Remove video', () => {
expect(transcodeAudioCodecOptions.some(i => i.value === TRANSCODE_REMOVE_AUDIO)).toBe(true);
const has = (options, value) => options.some(i => i.value === value);
expect(has(audioCodecOptionsFor({audioOnly: false, removeVideo: false}), TRANSCODE_REMOVE_AUDIO)).toBe(true);
expect(has(audioCodecOptionsFor({audioOnly: true, removeVideo: false}), TRANSCODE_REMOVE_AUDIO)).toBe(false);
expect(has(audioCodecOptionsFor({audioOnly: false, removeVideo: true}), TRANSCODE_REMOVE_AUDIO)).toBe(false);
// The real codecs and Keep are never withdrawn.
expect(audioCodecOptionsFor({audioOnly: true, removeVideo: false}).map(i => i.value))
.toEqual([TRANSCODE_COPY, 'aac', 'opus', 'mp3']);
expect(has(videoCodecOptionsFor({removeAudio: false}), TRANSCODE_REMOVE_VIDEO)).toBe(true);
expect(has(videoCodecOptionsFor({removeAudio: true}), TRANSCODE_REMOVE_VIDEO)).toBe(false);
expect(has(videoCodecOptionsFor({removeAudio: true}), 'h264')).toBe(true);
});
test('Remove video and Remove audio can never be chosen together', () => {
const keepBoth = {videoCodec: TRANSCODE_COPY, audioCodec: TRANSCODE_COPY};
// Removing one stream after the other was chosen puts the other back to Keep.
expect(chooseCodecs({videoCodec: TRANSCODE_REMOVE_VIDEO, audioCodec: 'aac'}, {audio: TRANSCODE_REMOVE_AUDIO}))
.toEqual({videoCodec: TRANSCODE_COPY, audioCodec: TRANSCODE_REMOVE_AUDIO});
expect(chooseCodecs({videoCodec: 'h264', audioCodec: TRANSCODE_REMOVE_AUDIO}, {video: TRANSCODE_REMOVE_VIDEO}))
.toEqual({videoCodec: TRANSCODE_REMOVE_VIDEO, audioCodec: TRANSCODE_COPY});
// Ordinary choices are untouched; a cleared select means Keep.
expect(chooseCodecs(keepBoth, {video: 'h264'})).toEqual({videoCodec: 'h264', audioCodec: TRANSCODE_COPY});
expect(chooseCodecs({videoCodec: 'h264', audioCodec: 'aac'}, {audio: null}))
.toEqual({videoCodec: 'h264', audioCodec: TRANSCODE_COPY});
expect(chooseCodecs(keepBoth, {audio: TRANSCODE_REMOVE_AUDIO}))
.toEqual({videoCodec: TRANSCODE_COPY, audioCodec: TRANSCODE_REMOVE_AUDIO});
});
test('WROL Mode disables starting a transcode', async () => {
renderWithProviders(
<TranscodeModal open={true} onClose={jest.fn()} fileGroupId={7} video={video}/>,

View file

@ -193,8 +193,8 @@ class VideoUpdateRequest:
@dataclass
class VideoTranscodeRequest:
video_codec: Optional[str] = None # A key of TRANSCODE_VIDEO_TARGETS, or None to copy the stream.
audio_codec: Optional[str] = None # A key of TRANSCODE_AUDIO_TARGETS, or None to copy the stream.
video_codec: Optional[str] = None # A key of TRANSCODE_VIDEO_TARGETS, REMOVE_VIDEO, or None to copy the stream.
audio_codec: Optional[str] = None # A key of TRANSCODE_AUDIO_TARGETS, REMOVE_AUDIO, or None to copy the stream.
container: str = 'mp4'
fragmented: bool = False # Fragmented mp4: quick start/seek for very long videos (mp4/m4a only).

View file

@ -1,4 +1,5 @@
"""Audio-only transcodes: removing the video stream from a video, and transcoding audio files."""
"""Audio-only transcodes: removing the video stream from a video, and transcoding audio files.
Also the mirror: removing the audio stream from a video (`REMOVE_AUDIO`)."""
import json
import pathlib
import shutil
@ -7,7 +8,7 @@ from unittest import mock
import pytest
from modules.videos.transcode import transcode_video_file, validate_transcode_request, verify_transcode_output, \
REMOVE_VIDEO, TRANSCODE_AUDIO_CONTAINERS, default_audio_container, transcode_video_job
REMOVE_VIDEO, REMOVE_AUDIO, TRANSCODE_AUDIO_CONTAINERS, default_audio_container, transcode_video_job
from wrolpi import jobs
from wrolpi.cmd import CommandResult
from wrolpi.vars import PROJECT_DIR
@ -263,3 +264,160 @@ async def test_transcode_api_remove_video_needs_audio_container(async_client, te
'container': 'm4a'}))
assert response.status == 200, response.json
jobs.cancel_job(response.json['job_id'])
# ------------------------------------------------------------------ remove audio
def test_validate_remove_audio():
"""Removing the audio needs a video container; both streams cannot be removed."""
validate_transcode_request(None, REMOVE_AUDIO, 'mp4')
validate_transcode_request('h264', REMOVE_AUDIO, 'mkv')
validate_transcode_request(None, REMOVE_AUDIO, 'mp4', fragmented=True)
with pytest.raises(ValueError, match='video container'):
validate_transcode_request(None, REMOVE_AUDIO, 'm4a')
with pytest.raises(ValueError, match='video container'):
validate_transcode_request(None, REMOVE_AUDIO, 'mp3')
with pytest.raises(ValueError, match='both'):
validate_transcode_request(REMOVE_VIDEO, REMOVE_AUDIO, 'mp4')
with pytest.raises(ValueError, match='both'):
validate_transcode_request(REMOVE_VIDEO, REMOVE_AUDIO, 'm4a')
def test_verify_remove_audio_output():
"""The output must have the video stream and must not have an audio stream."""
source = make_probe('vp9', 'opus', 100.0)
verify_transcode_output(source, make_probe('h264', None, 100.0), 'h264', REMOVE_AUDIO, 'mp4')
verify_transcode_output(source, make_probe('vp9', None, 100.0), None, REMOVE_AUDIO, 'mp4')
with pytest.raises(RuntimeError, match='still has an audio stream'):
verify_transcode_output(source, make_probe('vp9', 'opus', 100.0), None, REMOVE_AUDIO, 'mp4')
with pytest.raises(RuntimeError, match='no video stream'):
verify_transcode_output(source, make_probe(None, None, 100.0), None, REMOVE_AUDIO, 'mp4')
# A silent source can have its (absent) audio removed; the result is unchanged.
verify_transcode_output(make_probe('vp9', None, 100.0), make_probe('vp9', None, 100.0), None, REMOVE_AUDIO, 'mp4')
@pytest.mark.asyncio
async def test_remove_audio(test_directory, async_client):
"""Removing the audio: the video is mapped, `-an` drops the audio, no `-c:a`, the output keeps a
video container and the video stream is copied unless a target is given."""
video_path = test_directory / 'movie.webm'
video_path.write_bytes(b'fake video data')
probes = FakeProbes(make_probe('vp9', 'opus', 10.0, 'matroska,webm'), make_probe('vp9', None, 10.0, 'matroska,webm'))
with mock.patch('modules.videos.transcode.probe_for_verify', side_effect=probes), \
mock.patch('modules.videos.transcode.run_command', side_effect=async_fake_ffmpeg) as mock_run:
result = await transcode_video_file(video_path, target_vcodec=None, target_acodec=REMOVE_AUDIO,
container='mkv')
assert result == test_directory / 'movie.mkv' and result.is_file()
assert not video_path.exists()
cmd = mock_run.call_args_list[0][0][0]
assert '-an' in cmd
assert '-vn' not in cmd
assert '0:a:0?' not in cmd and '0:a:0' not in cmd
assert cmd[cmd.index('-map') + 1] == '0:V:0'
assert '-c:a' not in cmd
assert cmd[cmd.index('-c:v') + 1] == 'copy'
assert str(cmd[-1]).endswith('movie.transcode.mkv')
@pytest.mark.asyncio
async def test_remove_audio_with_video_target(test_directory, async_client):
video_path = test_directory / 'movie.webm'
video_path.write_bytes(b'fake video data')
probes = FakeProbes(make_probe('vp9', 'opus', 10.0, 'matroska,webm'), make_probe('h264', None, 10.0))
with mock.patch('modules.videos.transcode.probe_for_verify', side_effect=probes), \
mock.patch('modules.videos.transcode.run_command', side_effect=async_fake_ffmpeg) as mock_run:
result = await transcode_video_file(video_path, target_vcodec='h264', target_acodec=REMOVE_AUDIO,
container='mp4')
assert result == test_directory / 'movie.mp4'
cmd = mock_run.call_args_list[0][0][0]
assert '-an' in cmd
assert cmd[cmd.index('-c:v') + 1] == 'libx264'
assert '-c:a' not in cmd
assert '+faststart' in cmd
@pytest.mark.asyncio
async def test_remove_audio_from_audio_source_is_refused(test_directory, async_client):
"""An audio file with its audio removed is nothing; ffmpeg is never run."""
audio_path = test_directory / 'song.mp3'
audio_path.write_bytes(b'fake audio data')
probes = FakeProbes(make_probe(None, 'mp3', 10.0, 'mp3'), make_probe(None, 'mp3', 10.0, 'mp3'))
with mock.patch('modules.videos.transcode.probe_for_verify', side_effect=probes), \
mock.patch('modules.videos.transcode.run_command', side_effect=async_fake_ffmpeg) as mock_run:
with pytest.raises(RuntimeError, match='no video stream'):
await transcode_video_file(audio_path, target_acodec=REMOVE_AUDIO, container='mp4')
mock_run.assert_not_called()
assert audio_path.is_file()
def test_resolve_output_refuses_removing_both():
"""Even without `validate_transcode_request`, ffmpeg is never asked for nothing."""
from modules.videos.transcode import resolve_output
with pytest.raises(RuntimeError, match='both'):
resolve_output(make_probe('h264', 'aac'), REMOVE_VIDEO, REMOVE_AUDIO, 'mp4')
with pytest.raises(RuntimeError, match='both'):
resolve_output(make_probe(None, 'aac'), REMOVE_VIDEO, REMOVE_AUDIO, 'mp3')
@pytest.mark.asyncio
async def test_remove_audio_job(test_session, test_directory, async_client, video_factory):
"""The Job removes the audio in place: same FileGroup, still a video."""
from modules.videos.models import Video
from wrolpi.files.models import FileGroup
video = video_factory()
video.file_group.length = 5
test_session.commit()
file_group_id = video.file_group_id
video_path = video.video_path
probes = FakeProbes(make_probe('h264', 'aac', 5.3), make_probe('h264', None, 5.3))
async def fake_run_command(cmd, stdout_callback=None, **kwargs):
if cmd[-1] != '-':
shutil.copy(PROJECT_DIR / 'test/big_buck_bunny_720p_1mb.mp4', cmd[-1])
return CommandResult(return_code=0, cancelled=False, stdout=b'', stderr=b'', elapsed=1)
with mock.patch('modules.videos.transcode.probe_for_verify', side_effect=probes), \
mock.patch('wrolpi.cmd.run_command', side_effect=fake_run_command):
job_id = transcode_video_job.enqueue(file_group_id=file_group_id, video_codec=None,
audio_codec=REMOVE_AUDIO, container='mp4')
record = await jobs.wait_for_job(job_id)
assert record['status'] == jobs.COMPLETE, record
assert video_path.with_suffix('.mp4').is_file()
test_session.expire_all()
video = Video.find_by_file_group_id(test_session, file_group_id)
assert video.file_group.mimetype.startswith('video/')
assert test_session.query(FileGroup).count() == 1
@pytest.mark.asyncio
async def test_transcode_api_remove_audio(async_client, test_session, video_factory, audio_factory):
"""Remove-audio is queued for a video with a video container; refused on an audio file, with an
audio container, and together with remove-video."""
video = video_factory()
audio = audio_factory()
test_session.commit()
request, response = await async_client.post(f'/api/videos/{video.file_group_id}/transcode',
content=json.dumps({'audio_codec': REMOVE_AUDIO, 'container': 'mp4'}))
assert response.status == 200, response.json
assert 'Remove audio' in jobs.get_job(response.json['job_id'])['description']
jobs.cancel_job(response.json['job_id'])
request, response = await async_client.post(f'/api/videos/{video.file_group_id}/transcode',
content=json.dumps({'audio_codec': REMOVE_AUDIO, 'container': 'm4a'}))
assert response.status == 400, response.json
request, response = await async_client.post(f'/api/videos/{video.file_group_id}/transcode',
content=json.dumps({'video_codec': REMOVE_VIDEO,
'audio_codec': REMOVE_AUDIO, 'container': 'mp4'}))
assert response.status == 400, response.json
request, response = await async_client.post(f'/api/videos/{audio.file_group_id}/transcode',
content=json.dumps({'audio_codec': REMOVE_AUDIO, 'container': 'mp4'}))
assert response.status == 400, response.json

View file

@ -57,6 +57,8 @@ AUDIO_CONTAINER_CODECS = {
}
# `target_vcodec` value meaning "drop the video stream"; the output is an audio file.
REMOVE_VIDEO = 'none'
# `target_acodec` value meaning "drop the audio stream"; the output is a silent video.
REMOVE_AUDIO = 'none'
# ffprobe's `format_name` token for each container (mkv reports "matroska,webm").
CONTAINER_FORMAT_NAMES = {'mp4': 'mp4', 'mkv': 'matroska', 'm4a': 'm4a', 'ogg': 'ogg', 'mp3': 'mp3'}
# `-movflags +faststart` is an mp4-muxer option; other muxers warn about it.
@ -184,7 +186,8 @@ async def transcode_video_file(video_path: pathlib.Path,
raise RuntimeError('ffmpeg was not found')
# No target for either stream is a remux: both streams are copied into the (new) container.
# `target_vcodec=REMOVE_VIDEO` (or an audio-only source) makes the output an audio file; see
# `resolve_output`, which also settles an unsuitable container.
# `resolve_output`, which also settles an unsuitable container. `target_acodec=REMOVE_AUDIO`
# makes the output a silent video.
lock = await _acquire_transcode_lock()
try:
@ -216,8 +219,9 @@ def verify_transcode_output(source: dict, output: dict, target_vcodec: Optional[
complete rendition of the source before the source is replaced by it.
Checks: the output parses (its index was written), it is in the requested container, it has a
video stream (and an audio stream when the source has one), each stream's codec is the target
or, when copied, the source's, and the duration matches within a tolerance.
video stream (and an audio stream when the source has one, unless the audio was removed), each
stream's codec is the target or, when copied, the source's, and the duration matches within a
tolerance.
@raise RuntimeError: describing the first failed check.
"""
@ -242,12 +246,17 @@ def verify_transcode_output(source: dict, output: dict, target_vcodec: Optional[
else:
if not output_video:
raise RuntimeError('Transcode output has no video stream')
if source_audio and not output_audio:
if target_acodec == REMOVE_AUDIO and output_audio:
raise RuntimeError(f'Transcode output still has an audio stream ({output_audio[0]})')
if source_audio and not output_audio and target_acodec != REMOVE_AUDIO:
raise RuntimeError('Transcode output has no audio stream, but the source has one')
expected_video = target_vcodec or (source_video[0] if source_video else None)
if expected_video and output_video[0] != expected_video:
raise RuntimeError(f'Transcode output video codec is {output_video[0]}, expected {expected_video}')
expected_audio = target_acodec or (source_audio[0] if source_audio else None)
if target_acodec == REMOVE_AUDIO:
expected_audio = None
else:
expected_audio = target_acodec or (source_audio[0] if source_audio else None)
if output_audio and expected_audio and output_audio[0] != expected_audio:
raise RuntimeError(f'Transcode output audio codec is {output_audio[0]}, expected {expected_audio}')
@ -307,8 +316,12 @@ def resolve_output(source_probe: dict, target_vcodec: Optional[str], target_acod
source_video = get_stream_codec_names(source_probe, 'video')
source_audio = get_stream_codec_names(source_probe, 'audio')
if target_vcodec == REMOVE_VIDEO and target_acodec == REMOVE_AUDIO:
raise RuntimeError('Cannot remove both the video and the audio; nothing would remain')
if target_vcodec and target_vcodec != REMOVE_VIDEO and not source_video:
raise RuntimeError(f'Cannot transcode video to {target_vcodec}: the file has no video stream')
if target_acodec == REMOVE_AUDIO and not source_video:
raise RuntimeError('Cannot remove the audio: the file has no video stream, nothing would remain')
audio_only = target_vcodec == REMOVE_VIDEO or not source_video
if not audio_only:
@ -354,16 +367,22 @@ async def _transcode_video_file(video_path: pathlib.Path, target_vcodec: Optiona
source_probe = await probe_for_verify(video_path)
audio_only, container = resolve_output(source_probe, target_vcodec, target_acodec, container)
audio_args = TRANSCODE_AUDIO_TARGETS[target_acodec] if target_acodec else ('-c:a', 'copy')
if audio_only:
# `-vn` also drops embedded cover art; the audio stream is required.
map_args = ('-map', '0:a:0', '-vn')
video_args = ()
audio_args = TRANSCODE_AUDIO_TARGETS[target_acodec] if target_acodec else ('-c:a', 'copy')
elif target_acodec == REMOVE_AUDIO:
# `-an`: a silent video; only the video stream is mapped.
map_args = ('-map', '0:V:0', '-an')
video_args = TRANSCODE_VIDEO_TARGETS[target_vcodec] if target_vcodec else ('-c:v', 'copy')
audio_args = ()
else:
# 0:V:0 excludes attached-picture streams (embedded thumbnails); 0:a:0? tolerates a video
# with no audio stream.
map_args = ('-map', '0:V:0', '-map', '0:a:0?')
video_args = TRANSCODE_VIDEO_TARGETS[target_vcodec] if target_vcodec else ('-c:v', 'copy')
audio_args = TRANSCODE_AUDIO_TARGETS[target_acodec] if target_acodec else ('-c:a', 'copy')
if container in FASTSTART_CONTAINERS and fragmented:
mux_args = ('-movflags', FRAGMENTED_MOVFLAGS, '-frag_duration', str(FRAGMENT_DURATION_US))
elif container in FASTSTART_CONTAINERS:
@ -438,12 +457,15 @@ async def _transcode_video_file(video_path: pathlib.Path, target_vcodec: Optiona
def validate_transcode_request(video_codec: Optional[str], audio_codec: Optional[str], container: str,
fragmented: bool = False):
"""@raise ValueError: when the request cannot be transcoded. No codec at all is a remux;
`video_codec=REMOVE_VIDEO` drops the video stream and needs an audio container; `fragmented`
`video_codec=REMOVE_VIDEO` drops the video stream and needs an audio container;
`audio_codec=REMOVE_AUDIO` drops the audio stream and needs a video container; `fragmented`
needs an mp4 container."""
if video_codec and video_codec != REMOVE_VIDEO and video_codec not in TRANSCODE_VIDEO_TARGETS:
raise ValueError(f'Cannot transcode video to {video_codec!r}; supported: {sorted(TRANSCODE_VIDEO_TARGETS)}')
if audio_codec and audio_codec not in TRANSCODE_AUDIO_TARGETS:
if audio_codec and audio_codec != REMOVE_AUDIO and audio_codec not in TRANSCODE_AUDIO_TARGETS:
raise ValueError(f'Cannot transcode audio to {audio_codec!r}; supported: {sorted(TRANSCODE_AUDIO_TARGETS)}')
if video_codec == REMOVE_VIDEO and audio_codec == REMOVE_AUDIO:
raise ValueError('Cannot remove both the video and the audio; nothing would remain')
containers = TRANSCODE_CONTAINERS + TRANSCODE_AUDIO_CONTAINERS
if container not in containers:
raise ValueError(f'Unsupported container {container!r}; supported: {containers}')
@ -451,6 +473,8 @@ def validate_transcode_request(video_codec: Optional[str], audio_codec: Optional
raise ValueError(f'A fragmented file must be mp4 (or m4a), not {container}')
if video_codec == REMOVE_VIDEO and container not in TRANSCODE_AUDIO_CONTAINERS:
raise ValueError(f'Removing the video needs an audio container ({TRANSCODE_AUDIO_CONTAINERS}), not {container}')
if audio_codec == REMOVE_AUDIO and container not in TRANSCODE_CONTAINERS:
raise ValueError(f'Removing the audio needs a video container ({TRANSCODE_CONTAINERS}), not {container}')
if container in TRANSCODE_AUDIO_CONTAINERS:
if video_codec and video_codec != REMOVE_VIDEO:
raise ValueError(f'A video stream cannot be stored in {container}; remove the video or choose a video container')

View file

@ -12,7 +12,7 @@ from wrolpi.errors import InvalidOrderBy, InvalidJob
from wrolpi.schema import JSONErrorResponse
from . import lib
from .. import schema
from ..transcode import transcode_video_job, validate_transcode_request, REMOVE_VIDEO
from ..transcode import transcode_video_job, validate_transcode_request, REMOVE_VIDEO, REMOVE_AUDIO
video_bp = Blueprint('Video', '/api/videos')
@ -88,8 +88,12 @@ async def video_transcode(_: Request, file_group_id: int, body: schema.VideoTran
is_audio = (video.file_group.mimetype or '').startswith('audio/')
if is_audio and body.video_codec and body.video_codec != REMOVE_VIDEO:
raise InvalidJob(f'This is an audio file; it has no video stream to transcode to {body.video_codec}')
if is_audio and body.audio_codec == REMOVE_AUDIO:
raise InvalidJob('This is an audio file; removing its audio would leave nothing')
if body.video_codec == REMOVE_VIDEO and not is_audio:
action = 'Extract audio from'
elif body.audio_codec == REMOVE_AUDIO:
action = 'Remove audio from'
elif not body.video_codec and not body.audio_codec:
action = 'Remux'
else: