886 lines
41 KiB
Python
886 lines
41 KiB
Python
from typing import Union, List, Tuple, Optional, Dict
|
||
import numpy as np
|
||
import json, os
|
||
import math
|
||
from .TimeUtils import TimeDelta
|
||
from pydantic import BaseModel, ConfigDict, computed_field
|
||
from ffmpeg import FFmpeg
|
||
from ffmpeg.asyncio import FFmpeg as AsyncFFmpeg
|
||
import soundfile as sf
|
||
import pyloudnorm as pyln
|
||
import noisereduce as nr
|
||
from pedalboard import (
|
||
Pedalboard,
|
||
Compressor,
|
||
Limiter,
|
||
HighpassFilter,
|
||
LowpassFilter,
|
||
Gain,
|
||
Reverb,
|
||
Chorus,
|
||
Distortion,
|
||
)
|
||
from pedalboard.io import AudioFile
|
||
from loguru import logger
|
||
from .PathUtils import FileUtils
|
||
from BowongModalFunctions.models.ffmpeg_worker_model import FFMpegSliceSegment
|
||
|
||
|
||
class MediaStream(BaseModel):
|
||
duration: float
|
||
codec_name: str
|
||
|
||
model_config = ConfigDict(extra='allow')
|
||
|
||
|
||
class AudioStream(MediaStream):
|
||
stream_type: str = "audio"
|
||
sample_rate: str
|
||
# bit_depth : str
|
||
# sample_fmt: str
|
||
|
||
model_config = ConfigDict(extra='allow')
|
||
|
||
|
||
class VideoStream(MediaStream):
|
||
stream_type: str = "video"
|
||
width: int
|
||
height: int
|
||
bit_rate: int
|
||
avg_frame_rate: str
|
||
|
||
@computed_field
|
||
@property
|
||
def video_bitrate(self) -> str:
|
||
return str(int(self.bit_rate / 1000)) + 'k'
|
||
|
||
@computed_field
|
||
@property
|
||
def video_frame_rate(self) -> float:
|
||
numerator, denominator = map(int, self.avg_frame_rate.split('/'))
|
||
if denominator != 0:
|
||
return numerator / denominator
|
||
return 0
|
||
|
||
model_config = ConfigDict(extra='allow')
|
||
|
||
|
||
class ImageStream(MediaStream):
|
||
stream_type: str = "image"
|
||
width: int
|
||
height: int
|
||
pix_fmt: str
|
||
|
||
model_config = ConfigDict(extra='allow')
|
||
|
||
|
||
class VideoMetadata(BaseModel):
|
||
streams: List[Union[VideoStream, ImageStream, AudioStream]]
|
||
|
||
model_config = ConfigDict(extra='allow')
|
||
|
||
|
||
class VideoUtils:
|
||
"""
|
||
python-ffmpeg package docs : https://python-ffmpeg.readthedocs.io/en/stable/
|
||
"""
|
||
|
||
@staticmethod
|
||
def ffprobe_video_format(media_path: str) -> VideoStream:
|
||
ffprobe = FFmpeg(executable="ffprobe").input(
|
||
media_path, print_format="json", show_streams=None
|
||
)
|
||
video_metadata = VideoMetadata.model_validate_json(ffprobe.execute())
|
||
return video_metadata.streams[0]
|
||
|
||
@staticmethod
|
||
def ffprobe_media_metadata(media_path: str) -> VideoMetadata:
|
||
ffprobe = FFmpeg(executable="ffprobe").input(
|
||
media_path, print_format="json", show_streams=None
|
||
)
|
||
video_metadata = VideoMetadata.model_validate_json(ffprobe.execute())
|
||
return video_metadata
|
||
|
||
@staticmethod
|
||
def ffprobe_video_duration(media_path: str) -> TimeDelta:
|
||
ffprobe_cmd = VideoUtils.ffmpeg_init(use_ffprobe=True)
|
||
ffprobe_cmd.input(media_path, print_format="json", show_streams=None)
|
||
metadata_json = ffprobe_cmd.execute()
|
||
metadata = VideoMetadata.model_validate_json(metadata_json)
|
||
return TimeDelta(seconds=metadata.streams[0].duration)
|
||
|
||
@staticmethod
|
||
def ffprobe_audio_duration(media_path: str) -> TimeDelta:
|
||
ffprobe_cmd = VideoUtils.ffmpeg_init(use_ffprobe=True)
|
||
ffprobe_cmd.input(media_path, print_format="json", show_streams=None)
|
||
metadata_json = ffprobe_cmd.execute()
|
||
metadata = VideoMetadata.model_validate_json(metadata_json)
|
||
return TimeDelta(seconds=metadata.streams[-1].duration)
|
||
|
||
@staticmethod
|
||
async def ffprobe_video_format_async(media_path: str) -> VideoStream:
|
||
ffprobe = AsyncFFmpeg(executable="ffprobe").input(
|
||
media_path, print_format="json", show_streams=None
|
||
)
|
||
video_metadata = VideoMetadata.model_validate_json(await ffprobe.execute())
|
||
return video_metadata.streams[0]
|
||
|
||
@staticmethod
|
||
def ffprobe_video_size(media_path: str) -> Tuple[int, int]:
|
||
"""
|
||
:param media_path: local path to video
|
||
:return: video_width, video_height
|
||
"""
|
||
ffprobe = FFmpeg(executable="ffprobe").input(
|
||
media_path, print_format="json", show_streams=None
|
||
)
|
||
video_metadata = VideoMetadata.model_validate_json(ffprobe.execute())
|
||
return video_metadata.streams[0].width, video_metadata.streams[0].height
|
||
|
||
@staticmethod
|
||
async def ffprobe_video_size_async(media_path: str) -> Tuple[int, int]:
|
||
ffprobe = AsyncFFmpeg(executable="ffprobe").input(
|
||
media_path, print_format="json", show_streams=None
|
||
)
|
||
video_metadata = VideoMetadata.model_validate_json(await ffprobe.execute())
|
||
return video_metadata.streams[0].width, video_metadata.streams[0].height
|
||
|
||
@staticmethod
|
||
def noise_reduce(audio_path: str, noise_sample_path: Optional[str] = None,
|
||
output_path: Optional[str] = None) -> str:
|
||
samplerate = 44100
|
||
with AudioFile(audio_path).resampled_to(float(samplerate)) as f:
|
||
audio = f.read(f.frames)
|
||
|
||
if noise_sample_path:
|
||
with AudioFile(noise_sample_path).resampled_to(float(samplerate)) as f:
|
||
noise_sample = f.read(f.frames)
|
||
else:
|
||
# 获取前2秒作为噪声样本
|
||
noise_sample_length = min(int(2 * samplerate), audio.shape[0])
|
||
noise_sample = audio[:noise_sample_length]
|
||
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(audio_path, "nr")
|
||
|
||
reduced_noise = nr.reduce_noise(y=audio, y_noise=noise_sample, sr=samplerate,
|
||
stationary=True, prop_decrease=0.75, n_std_thresh_stationary=1.5,
|
||
n_fft=2048, win_length=1024, hop_length=512, n_jobs=1)
|
||
|
||
board = Pedalboard(
|
||
[
|
||
HighpassFilter(cutoff_frequency_hz=150),
|
||
LowpassFilter(cutoff_frequency_hz=8000),
|
||
Reverb(room_size=0.08, damping=0.7, wet_level=0.08,
|
||
dry_level=0.92, width=0.4),
|
||
Chorus(rate_hz=0.7, depth=0.12, centre_delay_ms=3.0, mix=0.10),
|
||
Distortion(drive_db=3.0),
|
||
Compressor(threshold_db=-30, ratio=1.8, attack_ms=20, release_ms=200),
|
||
Compressor(threshold_db=-24, ratio=2.2, attack_ms=15, release_ms=180),
|
||
Compressor(threshold_db=-18, ratio=1.5, attack_ms=10, release_ms=150),
|
||
Gain(gain_db=4),
|
||
Limiter(threshold_db=-6, release_ms=200),
|
||
]
|
||
)
|
||
# Convert to float32 if not already
|
||
reduced_noise = reduced_noise.astype(np.float32)
|
||
# Ensure audio is in the correct range (-1.0 to 1.0)
|
||
if np.abs(reduced_noise).max() > 1.0:
|
||
reduced_noise = reduced_noise / np.abs(reduced_noise).max()
|
||
|
||
processed_audio = board(reduced_noise, samplerate)
|
||
# 格式处理
|
||
if len(processed_audio.shape) == 1:
|
||
processed_audio = processed_audio.reshape(-1, 1)
|
||
elif len(processed_audio.shape) == 2:
|
||
if processed_audio.shape[0] < processed_audio.shape[1]:
|
||
processed_audio = processed_audio.T
|
||
if processed_audio.shape[1] > 2:
|
||
processed_audio = processed_audio[:, :2]
|
||
# 响度标准化
|
||
meter = pyln.Meter(samplerate)
|
||
min_samples = int(0.4 * samplerate)
|
||
|
||
if processed_audio.shape[0] < min_samples:
|
||
normalized_audio = processed_audio
|
||
else:
|
||
loudness = meter.integrated_loudness(processed_audio)
|
||
safety_factor = 0.7
|
||
processed_audio = processed_audio * safety_factor
|
||
normalized_audio = pyln.normalize.loudness(
|
||
processed_audio, loudness, -16.0
|
||
)
|
||
|
||
max_peak = np.max(np.abs(normalized_audio))
|
||
if max_peak > 0.85:
|
||
additional_safety_factor = 0.85 / max_peak
|
||
normalized_audio = normalized_audio * additional_safety_factor
|
||
|
||
sf.write(
|
||
output_path,
|
||
normalized_audio,
|
||
samplerate,
|
||
format="WAV",
|
||
subtype="PCM_16",
|
||
)
|
||
return output_path
|
||
|
||
@staticmethod
|
||
def async_ffmpeg_init(use_ffprobe: bool = False) -> AsyncFFmpeg:
|
||
if use_ffprobe:
|
||
ffmpeg_cmd = AsyncFFmpeg('ffprobe')
|
||
else:
|
||
ffmpeg_cmd = AsyncFFmpeg().option('y').option('hide_banner')
|
||
|
||
@ffmpeg_cmd.on("start")
|
||
def on_start(arguments: list[str]):
|
||
try:
|
||
filter_index = arguments.index("-filter_complex")
|
||
filter_content = arguments[filter_index + 1]
|
||
arguments[filter_index + 1] = f'"{filter_content}"'
|
||
args = " ".join(arguments)
|
||
logger.info(f"FFmpeg command:{args}")
|
||
arguments[filter_index + 1] = filter_content
|
||
except ValueError:
|
||
args = " ".join(arguments)
|
||
logger.info(f"FFmpeg command:{args}")
|
||
|
||
@ffmpeg_cmd.on("progress")
|
||
def on_progress(progress):
|
||
logger.info(f"处理进度: {progress}")
|
||
|
||
@ffmpeg_cmd.on("completed")
|
||
def on_completed():
|
||
logger.info(f"FFMpeg task completed.")
|
||
|
||
@ffmpeg_cmd.on("stderr")
|
||
def on_stderr(line: str):
|
||
if line.startswith('Error'):
|
||
logger.error(line)
|
||
raise RuntimeError(line)
|
||
else:
|
||
logger.warning(line)
|
||
|
||
return ffmpeg_cmd
|
||
|
||
@staticmethod
|
||
def ffmpeg_init(use_ffprobe: bool = False) -> FFmpeg:
|
||
if use_ffprobe:
|
||
ffmpeg_cmd = FFmpeg('ffprobe')
|
||
else:
|
||
ffmpeg_cmd = FFmpeg().option('y').option('hide_banner')
|
||
|
||
@ffmpeg_cmd.on("start")
|
||
def on_start(arguments: list[str]):
|
||
try:
|
||
filter_index = arguments.index("-filter_complex")
|
||
filter_content = arguments[filter_index + 1]
|
||
arguments[filter_index + 1] = f'"{filter_content}"'
|
||
args = " ".join(arguments)
|
||
logger.info(f"FFmpeg command:{args}")
|
||
arguments[filter_index + 1] = filter_content
|
||
except ValueError:
|
||
args = " ".join(arguments)
|
||
logger.info(f"FFmpeg command:{args}")
|
||
|
||
@ffmpeg_cmd.on("progress")
|
||
def on_progress(progress):
|
||
logger.info(f"处理进度: {progress}")
|
||
|
||
@ffmpeg_cmd.on("completed")
|
||
def on_completed():
|
||
logger.info(f"FFMpeg task completed.")
|
||
|
||
@ffmpeg_cmd.on("stderr")
|
||
def on_stderr(line: str):
|
||
if line.startswith('Error'):
|
||
logger.error(line)
|
||
raise RuntimeError(line)
|
||
else:
|
||
logger.warning(line)
|
||
|
||
return ffmpeg_cmd
|
||
|
||
@staticmethod
|
||
async def ffmpeg_slice_media(media_path: str, media_markers: List[FFMpegSliceSegment],
|
||
output_path: Optional[str] = None) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
使用本地视频文件按时间段切割出分段视频
|
||
:param media_path: 本地视频路径
|
||
:param media_markers: 分段起始结束时间标记
|
||
:param output_path: 最终输出文件路径, 片段会根据指定路径附加_1.mp4， _2.mp4等片段编号
|
||
:return: 输出片段的本地路径
|
||
"""
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path)
|
||
filter_complex: List[str] = []
|
||
temp_outputs: List[str] = []
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, "slice")
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path=media_path)
|
||
|
||
for index, marker in enumerate(media_markers):
|
||
filter_complex.extend(
|
||
[
|
||
f"[v:0]trim=start={marker.start.total_seconds()}:end={marker.end.total_seconds()},setpts=PTS-STARTPTS[cut{index}]",
|
||
f"[a:0]atrim=start={marker.start.total_seconds()}:end={marker.end.total_seconds()},asetpts=PTS-STARTPTS[acut{index}]",
|
||
]
|
||
)
|
||
ffmpeg_cmd.option('filter_complex', ';'.join(filter_complex))
|
||
|
||
for i, marker in enumerate(media_markers):
|
||
if marker.start.total_seconds() > video_metadata.duration or marker.start.total_seconds() < 0:
|
||
raise ValueError(
|
||
f"第{i}个切割点起始点{marker.start.total_seconds()}s超出视频时长[0-{video_metadata.duration}s]范围")
|
||
if marker.end.total_seconds() > video_metadata.duration or marker.end.total_seconds() < 0:
|
||
raise ValueError(
|
||
f"第{i}个切割点结束点{marker.end.total_seconds()}s超出视频时长[0-{video_metadata.duration}s]范围")
|
||
segment_output_path = FileUtils.file_path_extend(output_path, str(i))
|
||
ffmpeg_cmd.output(segment_output_path,
|
||
map=[f"[cut{i}]", f"[acut{i}]"],
|
||
reset_timestamps="1",
|
||
sc_threshold="0",
|
||
g="1",
|
||
force_key_frames="expr:gte(t,n_forced*1)",
|
||
vcodec="libx264",
|
||
acodec="aac",
|
||
crf=16,
|
||
r=30,
|
||
)
|
||
temp_outputs.append(segment_output_path)
|
||
|
||
await ffmpeg_cmd.execute()
|
||
outputs: List[Tuple[str, VideoMetadata]] = [(output, VideoUtils.ffprobe_media_metadata(output)) for output in
|
||
temp_outputs]
|
||
return outputs
|
||
|
||
@staticmethod
|
||
async def ffmpeg_slice_stream_media(media_path: str,
|
||
media_markers: List[FFMpegSliceSegment],
|
||
output_path: Optional[str] = None) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
按时间分段切割HLS视频流
|
||
:param media_path: hls manifest URL
|
||
:param media_markers: 分段起始结束时间标记
|
||
:param output_path: 最终输出文件路径, 片段会根据指定路径附加_1.mp4， _2.mp4等片段编号
|
||
:return: 输出片段的本地路径， 输出片段时长
|
||
"""
|
||
import m3u8
|
||
playlist = m3u8.load(media_path)
|
||
stream_total_duration: float = sum(segment.duration for segment in playlist.segments)
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path,
|
||
protocol_whitelist="file,http,https,tcp,tls",
|
||
reconnect="1", # 自动重连
|
||
reconnect_streamed="1",
|
||
reconnect_delay_max="5")
|
||
filter_complex: List[str] = []
|
||
|
||
temp_outputs: List[str] = []
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, "slice")
|
||
if not output_path.endswith(".mp4"):
|
||
output_path = output_path + ".mp4"
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
|
||
for index, marker in enumerate(media_markers):
|
||
if marker.start.total_seconds() > stream_total_duration or marker.start.total_seconds() < 0:
|
||
raise ValueError(
|
||
f"第{index}个切割点起始点{marker.start.total_seconds()}s超出视频时长[0-{stream_total_duration}s]范围")
|
||
if marker.end.total_seconds() > stream_total_duration or marker.end.total_seconds() < 0:
|
||
raise ValueError(
|
||
f"第{index}个切割点结束点{marker.end.total_seconds()}s超出视频时长[0-{stream_total_duration}s]范围")
|
||
|
||
filter_complex.extend(
|
||
[
|
||
f"[v:0]trim=start={marker.start.total_seconds()}:end={marker.end.total_seconds()},setpts=PTS-STARTPTS[cut{index}]",
|
||
f"[a:0]atrim=start={marker.start.total_seconds()}:end={marker.end.total_seconds()},asetpts=PTS-STARTPTS[acut{index}]",
|
||
]
|
||
)
|
||
ffmpeg_cmd.option('filter_complex', ';'.join(filter_complex))
|
||
for i, marker in enumerate(media_markers):
|
||
output_filepath = FileUtils.file_path_extend(output_path, str(i))
|
||
ffmpeg_cmd.output(output_filepath,
|
||
map=[f"[cut{i}]", f"[acut{i}]"],
|
||
reset_timestamps="1",
|
||
sc_threshold="0",
|
||
g="1",
|
||
force_key_frames="expr:gte(t,n_forced*1)",
|
||
vcodec="libx264",
|
||
acodec="aac",
|
||
crf=16,
|
||
r=30, )
|
||
temp_outputs.append(output_filepath)
|
||
await ffmpeg_cmd.execute()
|
||
outputs: List[Tuple[str, VideoMetadata]] = [(output, VideoUtils.ffprobe_media_metadata(output)) for output in
|
||
temp_outputs]
|
||
return outputs
|
||
|
||
@staticmethod
|
||
async def ffmpeg_convert_stream_media(media_stream_url: str,
|
||
output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_stream_url, "convert")
|
||
if not output_path.endswith(".mp4"):
|
||
output_path = output_path + ".mp4"
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_stream_url,
|
||
protocol_whitelist="file,http,https,tcp,tls",
|
||
reconnect="1", # 自动重连
|
||
reconnect_streamed="1",
|
||
reconnect_delay_max="5")
|
||
ffmpeg_cmd.output(output_path,
|
||
reset_timestamps="1",
|
||
sc_threshold="0",
|
||
g="1",
|
||
force_key_frames="expr:gte(t,n_forced*1)",
|
||
vcodec="libx264",
|
||
acodec="aac",
|
||
crf=16,
|
||
r=30, )
|
||
await ffmpeg_cmd.execute()
|
||
output: Tuple[str, VideoMetadata] = (output_path, VideoUtils.ffprobe_media_metadata(output_path))
|
||
return output
|
||
|
||
@staticmethod
|
||
async def ffmpeg_concat_medias(media_paths: List[str],
|
||
target_width: int = 1080,
|
||
target_height: int = 1920,
|
||
output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
将待处理的视频合并为一个视频
|
||
:param media_paths: 待合并的多个视频文件路径
|
||
:param target_width: 输出的视频分辨率宽
|
||
:param target_height: 输出的视频分辨率高
|
||
:param output_path: 指定输出视频路径
|
||
:return: 最终合并结果路径，最终合并结果时长
|
||
"""
|
||
|
||
total_videos = len(media_paths)
|
||
if total_videos == 0:
|
||
raise ValueError("没有可以合并的视频源")
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_paths[0], "concat")
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
filter_complex = []
|
||
for input_path in media_paths:
|
||
ffmpeg_cmd.input(input_path)
|
||
# 2. 统一所有视频的格式、分辨率和帧率
|
||
for i in range(total_videos):
|
||
filter_complex.extend(
|
||
[
|
||
# 先缩放到统一分辨率，然后设置帧率和格式
|
||
f"[{i}:v]scale={target_width}:{target_height}:force_original_aspect_ratio=decrease,"
|
||
f"pad={target_width}:{target_height}:(ow-iw)/2:(oh-ih)/2,"
|
||
f"setsar=1:1," # 新增强制设置SAR
|
||
f"fps=30,format=yuv420p[v{i}]",
|
||
f"[{i}:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo[a{i}]",
|
||
]
|
||
)
|
||
# 3. 准备处理后的视频流和音频流的连接字符串
|
||
video_streams = "".join(f"[v{i}]" for i in range(total_videos))
|
||
audio_streams = "".join(f"[a{i}]" for i in range(total_videos))
|
||
|
||
# 4. 使用concat过滤器合并视频和音频
|
||
filter_complex.extend(
|
||
[
|
||
f"{video_streams}concat=n={total_videos}:v=1:a=0[vconcated]",
|
||
f"{audio_streams}concat=n={total_videos}:v=0:a=1[aconcated]",
|
||
]
|
||
)
|
||
|
||
ffmpeg_cmd.output(
|
||
output_path,
|
||
{
|
||
"filter_complex": ";".join(filter_complex),
|
||
"map": ["[vconcated]", "[aconcated]"],
|
||
"vcodec": "libx264",
|
||
"crf": 16,
|
||
"r": 30,
|
||
"acodec": "aac",
|
||
"ar": 44100,
|
||
"ac": 2,
|
||
"ab": "192k",
|
||
},
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_extract_audio_async(media_path: str, output_path: Optional[str] = None) -> Tuple[
|
||
str, VideoMetadata]:
|
||
"""
|
||
提取源视频的音频
|
||
:param media_path: 待处理的源视频
|
||
:param output_path: 指定输出的音频文件路径（可选）
|
||
:return: 最终输出音频文件路径，音频文件时长
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_change_extension(output_path, 'wav')
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
ffprobe_cmd = VideoUtils.async_ffmpeg_init(use_ffprobe=True)
|
||
ffprobe_cmd.input(media_path,
|
||
v="quiet",
|
||
print_format="json",
|
||
select_streams="a",
|
||
show_entries="stream=codec_type")
|
||
audio_check_bytes = await ffprobe_cmd.execute()
|
||
audio_check = json.loads(audio_check_bytes)
|
||
logger.info(audio_check)
|
||
if len(audio_check['streams']) == 0:
|
||
raise RuntimeError(f"Media has no audio streams.")
|
||
# output_path = f"{output_path_prefix}/extract_audio/outputs/{fn_id}/output.wav"
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path).output(output_path,
|
||
map="0:a",
|
||
acodec="pcm_s16le",
|
||
ar=44100,
|
||
ac=1)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_mix_bgm(origin_audio_path: str, bgm_audio_path: str, video_volume: float = 1.4,
|
||
music_volume: float = 0.1, output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
给待处理视频混合BGM
|
||
:param origin_audio_path: 待处理的源视频
|
||
:param bgm_audio_path: 需要混合的BGM
|
||
:param video_volume: 最终输出视频的音量系数
|
||
:param music_volume: BGM在源视频音量内占比的音量系数
|
||
:param output_path: 指定最终输出的视频路径（可选）
|
||
:return: 最终输出视频文件路径，最终输出视频时长
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(origin_audio_path, "bgm")
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
origin_audio_duration = VideoUtils.ffprobe_audio_duration(origin_audio_path)
|
||
bgm_duration = VideoUtils.ffprobe_audio_duration(bgm_audio_path)
|
||
loops_needed = math.ceil(origin_audio_duration.total_seconds() / bgm_duration.total_seconds())
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init(use_ffprobe=True)
|
||
ffmpeg_cmd.input(origin_audio_path)
|
||
ffmpeg_cmd.input(bgm_audio_path)
|
||
filter_complex = [
|
||
f"[0:a]volume={video_volume}[a1]",
|
||
f"[1:a]aloop=loop={loops_needed}:size={bgm_duration.total_seconds()},volume={music_volume}[a2]"
|
||
"[a1][a2]amix=inputs=2:duration=first[audio]"
|
||
]
|
||
ffmpeg_cmd.output(output_path,
|
||
options={"filter_complex": ";".join(filter_complex), },
|
||
map="[audio]",
|
||
acodec='libmp3lame', # 音频编码器
|
||
ar=48000, # 音频采样率
|
||
ab='192k', # 音频码率
|
||
ac=2, # 音频通道数
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_mix_bgm_with_noise_reduce(media_path: str,
|
||
bgm_audio_path: str,
|
||
video_volume: float = 1.4,
|
||
music_volume: float = 0.1,
|
||
noise_sample_path: Optional[str] = None,
|
||
temp_audio_path: Optional[str] = None,
|
||
output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
先对待处理的视频音轨降噪，再将降噪后的结果添加BGM，最终输出降噪过且混合BGM的视频；
|
||
由于最终视频画面和音轨是同步混合+合成视频，所以处理速度会比分步降噪, 加BGM快；
|
||
:param media_path: 待处理的原始视频路径
|
||
:param bgm_audio_path: 待处理的BGM音频路径
|
||
:param video_volume: 最终输出的视频音量系数
|
||
:param music_volume: 最终输出的BGM音量系数
|
||
:param noise_sample_path: 降噪使用的噪音样本，如不指定将使用源视频的前2秒作为样本（可选）
|
||
:param temp_audio_path: 指定暂存音频的路径（可选）
|
||
:param output_path: 指定输出视频的路径（可选）
|
||
:return: 最终输出视频的路径， 最终输出视频时长
|
||
"""
|
||
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, "bgm_nr")
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
if not temp_audio_path:
|
||
temp_audio_path = FileUtils.file_path_extend(media_path, "temp")
|
||
temp_audio_path = FileUtils.file_path_change_extension(temp_audio_path, "wav")
|
||
media_audio, metadata = await VideoUtils.ffmpeg_extract_audio_async(media_path=media_path,
|
||
output_path=temp_audio_path)
|
||
logger.info(f"media_audio = {media_audio}, metadata = {metadata}")
|
||
nr_audio_path = VideoUtils.noise_reduce(audio_path=media_audio, noise_sample_path=noise_sample_path)
|
||
logger.info(f"nr_audio_path = {nr_audio_path}")
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path)
|
||
origin_audio_duration = VideoUtils.ffprobe_audio_duration(nr_audio_path)
|
||
bgm_duration = VideoUtils.ffprobe_audio_duration(bgm_audio_path)
|
||
loops_needed = math.ceil(origin_audio_duration.total_seconds() / bgm_duration.total_seconds())
|
||
logger.info(
|
||
f"{bgm_duration.total_seconds()}s的BGM循环{loops_needed}次, 填充{origin_audio_duration.total_seconds()}s的视频长度")
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path)
|
||
ffmpeg_cmd.input(nr_audio_path)
|
||
ffmpeg_cmd.input(bgm_audio_path)
|
||
filter_complex = [
|
||
f"[1:a]volume={video_volume}[a1]",
|
||
f"[2:a]aloop=loop={loops_needed}:size={bgm_duration.total_seconds()},volume={music_volume}[a2]",
|
||
"[a1][a2]amix=inputs=2:duration=first[audio]"
|
||
]
|
||
ffmpeg_cmd.output(output_path,
|
||
options={"filter_complex": ";".join(filter_complex), },
|
||
map=["0:v", "[audio]"],
|
||
crf=16,
|
||
vcodec='libx264',
|
||
b=video_metadata.video_bitrate, # 视频码率
|
||
r=video_metadata.video_frame_rate, # 帧率
|
||
acodec='libmp3lame',
|
||
ar=48000, ab='192k', ac=2,
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_overlay_gif(media_path: str, overlay_gif_path: str, output_path: Optional[str] = None) -> Tuple[
|
||
str, VideoMetadata]:
|
||
"""
|
||
将GIF特效叠加到视频上，如果视频较长则循环播放GIF
|
||
:param media_path: 输入视频路径
|
||
:param overlay_gif_path: GIF特效文件路径
|
||
:param output_path: 指定输出路径
|
||
:return: 输出视频路径， 最终输出视频时长
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, "overlay")
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path)
|
||
filter_complex = [
|
||
# 确保GIF正确解码并循环
|
||
"[1:v]fps=30,format=rgba[gif]", # 强制设置30fps
|
||
# 叠加GIF到视频上，保持透明通道
|
||
"[0:v][gif]overlay=shortest=1:format=auto,setpts=PTS-STARTPTS[v]",
|
||
]
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path)
|
||
ffmpeg_cmd.input(overlay_gif_path, stream_loop=-1) # 使用stream_loop让GIF循环直到视频结束
|
||
ffmpeg_cmd.output(output_path,
|
||
options={"filter_complex": ";".join(filter_complex), },
|
||
map=["[v]", "0:a"],
|
||
crf=16,
|
||
vcodec='libx264',
|
||
b=video_metadata.video_bitrate, # 视频码率
|
||
r=video_metadata.video_frame_rate, # 帧率
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_zoom_loop(media_path: str, duration: float = 6.0, zoom: float = 0.1,
|
||
output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
视频放大缩小循环特效
|
||
:param media_path: 待处理的视频文件路径
|
||
:param duration: 视频特效循环时间长度
|
||
:param zoom: 视频特效放大缩小系数
|
||
:param output_path: 指定输出视频地址（可选）
|
||
:return: 最终输出视频地址， 最终输出视频时长
|
||
"""
|
||
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, 'zoomed')
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path)
|
||
# abs(sin())表达式会导致实际的往复频率为2倍
|
||
duration = duration * 2
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path).output(output_path,
|
||
options={
|
||
"vf": f"scale={4 * video_metadata.width}x{4 * video_metadata.height},fps=30,"
|
||
f"zoompan=z='1+{zoom}*abs(sin(2*PI*time/{duration}))':"
|
||
"x='trunc(iw/2*(1-1/zoom))':"
|
||
"y='trunc(ih/2*(1-1/zoom))':"
|
||
f"d=1:s={video_metadata.width}x{video_metadata.height}:fps=30"
|
||
},
|
||
vcodec="libx264",
|
||
acodec="copy",
|
||
crf=16,
|
||
b=video_metadata.video_bitrate, # 视频码率
|
||
r=video_metadata.video_frame_rate, # 帧率
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_corner_mirror(media_path: str, mirror_scale_down_size: int = 6,
|
||
mirror_from_right: bool = True, mirror_position: tuple[float, float] = (40, 40),
|
||
output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
对源视频添加镜像小窗特效
|
||
:param media_path: 待处理的源视频
|
||
:param mirror_scale_down_size: 源视频画面缩放系数
|
||
:param mirror_from_right: 小窗原点是否使用右下角
|
||
:param mirror_position: 小窗基于原点坐标轴的偏移量
|
||
:param output_path: 指定的输出视频路径（可选）
|
||
:return: 返回最终输出视频的路径， 最终输出视频时长
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, 'mir')
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
|
||
mirror_x = (
|
||
f"main_w-overlay_w-{mirror_position[0]}"
|
||
if mirror_from_right
|
||
else str(mirror_position[0])
|
||
)
|
||
filter_complex = [
|
||
"[0:v]split[original][mirror]",
|
||
f"[mirror]hflip,scale=iw/{mirror_scale_down_size}:-1,format=rgba[flipped]",
|
||
"[flipped]split[fm1][fm2]",
|
||
f"[fm2]format=gray,geq=lum='255*(1-pow(min(1,2*sqrt(pow(X/W-0.5,2)+pow(Y/H-0.5,2))),1.5))':a='if(lt(pow(X/W-0.5,2)+pow(Y/H-0.5,2),0.15),(1-pow(2*sqrt(pow(X/W-0.5,2)+pow(Y/H-0.5,2)),1.5))*255,0)'[fm2Blur]",
|
||
"[fm1][fm2Blur]alphamerge[flipped_blured]",
|
||
f"[original][flipped_blured]overlay=x={mirror_x}:y=main_h-overlay_h-{mirror_position[1]}[video]",
|
||
]
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path)
|
||
ffmpeg_cmd.input(media_path).output(output_path,
|
||
options={"filter_complex": ";".join(filter_complex)},
|
||
map=["[video]", "0:a"],
|
||
vcodec="libx264",
|
||
crf=16,
|
||
b=video_metadata.video_bitrate, # 视频码率
|
||
r=video_metadata.video_frame_rate # 帧率
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_subtitle_apply(media_path: str, subtitle_path: str,
|
||
font_dir: str, output_path: Optional[str] = None) -> Tuple[str, VideoMetadata]:
|
||
"""
|
||
给视频画面叠加字幕，需要确保字幕文件为ass字幕，并且subtitle文件内设置的字体存在与font_dir文件夹内
|
||
:param media_path: 待处理的源视频
|
||
:param subtitle_path: ass字幕文件路径
|
||
:param font_dir: 字体文件目录路径
|
||
:param output_path: 指定输出文件路径（可选）
|
||
:return: 返回最终输出视频路径， 最终输出视频时长
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(media_path, 'sub')
|
||
|
||
video_metadata = VideoUtils.ffprobe_video_format(media_path)
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(media_path)
|
||
ffmpeg_cmd.output(output_path,
|
||
vf=f"subtitles=filename={subtitle_path}:fontsdir={font_dir}",
|
||
vcodec="libx264",
|
||
crf=16,
|
||
b=video_metadata.video_bitrate, # 视频码率
|
||
r=video_metadata.video_frame_rate, # 帧率
|
||
acodec="copy",
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_fill_longest(video_path: str, audio_path: str, output_path: Optional[str] = None) -> Tuple[
|
||
str, VideoMetadata]:
|
||
"""
|
||
用视频循环对齐音频时长，如果短于音频时长则循环填满音频时长，如短于音频时长则裁剪结尾
|
||
:param video_path: 使用的视频文件路径
|
||
:param audio_path: 匹配的音频文件路径
|
||
:param output_path: 指定输出文件地址
|
||
:return: 最终输出的文件路径， 最终输出视频详细信息
|
||
"""
|
||
video_metadata = VideoUtils.ffprobe_video_format(video_path)
|
||
audio_duration = VideoUtils.ffprobe_audio_duration(audio_path)
|
||
loop_times = 0 if video_metadata.duration > audio_duration.total_seconds() else int(
|
||
math.ceil(audio_duration.total_seconds() / video_metadata.duration))
|
||
logger.info(
|
||
f"视频长度 = {video_metadata.duration}, 音频长度 = {audio_duration.total_seconds()}, 重复 = {loop_times}")
|
||
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(video_path, 'fill')
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(video_path, stream_loop=str(loop_times))
|
||
ffmpeg_cmd.input(audio_path)
|
||
|
||
ffmpeg_cmd.output(output_path,
|
||
map=["0:v", "1:a"],
|
||
vcodec="copy",
|
||
acodec="aac",
|
||
shortest=None,
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
video_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, video_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_extract_frame_image(video_path: str, frame_index: int, output_path: Optional[str] = None) -> Tuple[
|
||
str, VideoMetadata]:
|
||
"""
|
||
获取视频的第n帧输出为图片, 并返回图片相关的元数据
|
||
"""
|
||
if not output_path:
|
||
output_path = FileUtils.file_path_extend(video_path, 'cover')
|
||
output_path = FileUtils.file_path_change_extension(output_path, 'jpg')
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(video_path)
|
||
ffmpeg_cmd.output(output_path, vframes=frame_index)
|
||
await ffmpeg_cmd.execute()
|
||
image_metadata = VideoUtils.ffprobe_media_metadata(output_path)
|
||
return output_path, image_metadata
|
||
|
||
@staticmethod
|
||
async def ffmpeg_stream_record_as_hls(stream_url: str,
|
||
segments_output_dir: str,
|
||
playlist_output_dir: str,
|
||
playlist_output_method: Optional[str] = None,
|
||
playlist_output_headers: Optional[Dict[str, str]] = None,
|
||
manifest_segment_prefix: Optional[str] = None,
|
||
segment_duration: float = 5.0,
|
||
stream_content_timeout: int = 300,
|
||
output_file_pattern: str = "%10d.ts"):
|
||
os.makedirs(segments_output_dir, exist_ok=True)
|
||
ffmpeg_cmd = VideoUtils.async_ffmpeg_init()
|
||
ffmpeg_cmd.input(stream_url,
|
||
protocol_whitelist="file,http,https,tcp,tls", # 使用flv
|
||
reconnect="1", # 自动重连
|
||
reconnect_at_eof="1",
|
||
reconnect_streamed="1",
|
||
reconnect_delay_max="5")
|
||
ffmpeg_cmd.output(
|
||
f"{playlist_output_dir}/playlist.m3u8",
|
||
f="hls",
|
||
method=playlist_output_method,
|
||
headers="\\r\\n".join([f"{header_key}:{playlist_output_headers[header_key]}" for header_key in
|
||
playlist_output_headers.keys()]) if playlist_output_headers else None,
|
||
hls_time=segment_duration,
|
||
hls_segment_filename=f"{segments_output_dir}/{output_file_pattern}",
|
||
hls_segment_type="mpegts",
|
||
hls_flags="append_list+independent_segments+program_date_time",
|
||
hls_base_url=manifest_segment_prefix if manifest_segment_prefix else None,
|
||
hls_playlist_type="event",
|
||
hls_list_size=0,
|
||
hls_start_number_source="epoch_us",
|
||
timeout=stream_content_timeout,
|
||
c="copy",
|
||
)
|
||
await ffmpeg_cmd.execute()
|
||
logger.info(f'停止录制')
|