import subprocess import os import glob from db import update_operation, update_file_media_info, get_operation_by_id, mark_backup_deleted, get_file_by_path, calculate_and_save_stats from mediascan import get_media_info_with_ffprobe from thumbnails import invalidate_thumbs from notifications import notify def detect_available_accelerators(): available = ["CPU"] # VAAPI — проверяем через vainfo на конкретных устройствах if _find_vaapi_device() is not None: available.append("VAAPI") # Intel QSV — требует intel-media-sdk/oneVPL и сборки ffmpeg с QSV if _has_ffmpeg_hwaccel("qsv") and _has_ffmpeg_encoder("h264_qsv"): available.append("QSV") # NVENC — наличие NVIDIA устройства или nvidia-smi if os.path.exists("/dev/nvidia0") or _cmd_succeeds(["nvidia-smi", "-L"]): available.append("NVENC") # AMF — AMD GPU + ffmpeg скомпилирован с AMF (на Linux AMF экспериментальный) if _has_amd_gpu() and _has_ffmpeg_encoder("h264_amf"): available.append("AMF") return available def _cmd_succeeds(cmd): try: result = subprocess.run(cmd, capture_output=True, timeout=5) return result.returncode == 0 except Exception: return False def _find_vaapi_device(): """Возвращает путь к первому рабочему VAAPI render-устройству или None.""" import glob as _glob for device in sorted(_glob.glob("/dev/dri/renderD*")): result = subprocess.run( ["vainfo", "--display", "drm", "--device", device], capture_output=True, timeout=5 ) if result.returncode == 0: return device # Fallback: vainfo без явного указания устройства if _cmd_succeeds(["vainfo"]): return "/dev/dri/renderD128" return None def _has_ffmpeg_encoder(encoder_name): try: result = subprocess.run(["ffmpeg", "-hide_banner", "-encoders"], capture_output=True, text=True, timeout=10) return encoder_name in result.stdout except Exception: return False def _has_ffmpeg_hwaccel(accel_name): try: result = subprocess.run(["ffmpeg", "-hide_banner", "-hwaccels"], capture_output=True, text=True, timeout=5) return accel_name in result.stdout except Exception: return False def _has_amd_gpu(): try: result = subprocess.run(["lspci"], capture_output=True, text=True, timeout=5) if result.returncode == 0: return any( ("vga" in line or "3d controller" in line) and ("amd" in line or "radeon" in line) for line in result.stdout.lower().splitlines() ) except Exception: pass return False def get_hardware_codec(software_codec, hardware_acceleration): codec_map = { "libx265": { "NVENC": "hevc_nvenc", "VAAPI": "hevc_vaapi", "QSV": "hevc_qsv", "AMF": "hevc_amf", "CPU": "libx265" }, "libx264": { "NVENC": "h264_nvenc", "VAAPI": "h264_vaapi", "QSV": "h264_qsv", "AMF": "h264_amf", "CPU": "libx264" }, "libaom-av1": { "NVENC": None, # NVENC не поддерживает AV1 в большинстве сборок "VAAPI": "av1_vaapi", # Intel Xe+, AMD RX 7000+ "QSV": "av1_qsv", # Intel Arc+ "AMF": "av1_amf", # AMD RX 7000+ "CPU": "libaom-av1" }, "libvpx-vp9": { "NVENC": None, # NVENC не поддерживает VP9 "VAAPI": "vp9_vaapi", # Только Intel VAAPI; на AMD почти не работает "QSV": None, # QSV VP9 encode не поддерживается "AMF": None, # AMF VP9 encode не поддерживается "CPU": "libvpx-vp9" } } # Проверка наличия кодека в таблице if software_codec not in codec_map: raise ValueError(f"Unsupported software codec: {software_codec}") if hardware_acceleration not in codec_map[software_codec]: raise ValueError(f"Unsupported hardware acceleration type: {hardware_acceleration}") # Получение аппаратного кодека hardware_codec = codec_map[software_codec][hardware_acceleration] if hardware_codec is None: return software_codec return hardware_codec # Ошибка CUDA-фильтра при изменении параметров видеопотока (BDRemux и т.п.) _NVENC_CUDA_FILTER_ERROR = "Impossible to convert between the formats supported by the filter" def get_ffmpeg_transcoding_cmd(file_path, acceleration, codec, resolution, crf, preset, cpu_used, output_file, _nvenc_full_cuda=False): software_codec = codec codec = get_hardware_codec(software_codec, acceleration) if codec == software_codec: acceleration = "CPU" width = resolution hw_input_flags = [] if acceleration == "VAAPI": vaapi_device = _find_vaapi_device() or "/dev/dri/renderD128" hw_input_flags = ["-vaapi_device", vaapi_device] elif acceleration == "NVENC": if _nvenc_full_cuda: # Полный CUDA-пайплайн: decode GPU → scale GPU → encode GPU hw_input_flags = ["-hwaccel", "cuda", "-hwaccel_output_format", "cuda"] else: # CPU-scale fallback: decode GPU → scale CPU → encode GPU hw_input_flags = ["-hwaccel", "cuda"] elif acceleration == "QSV": hw_input_flags = ["-hwaccel", "qsv"] # AMF: не требует hwaccel-флага на Linux — AMF SDK сам управляет устройством if acceleration == "VAAPI": vf = f"format=nv12,hwupload,scale_vaapi={width}:-2" elif acceleration == "NVENC" and _nvenc_full_cuda: vf = f"scale_cuda={width}:-2:passthrough=0:format=yuv420p" else: vf = f"scale={width}:-2" nvenc_preset_map = { "ultrafast": "p1", "superfast": "p1", "veryfast": "p2", "faster": "p3", "fast": "p4", "medium": "p5", "slow": "p6", "slower": "p7", "veryslow": "p7" } amf_preset_map = { "ultrafast": "speed", "superfast": "speed", "veryfast": "speed", "faster": "speed", "fast": "speed", "medium": "balanced", "slow": "quality", "slower": "quality", "veryslow": "quality" } if acceleration == "NVENC": quality_flag, quality_value = "-cq", str(crf) elif acceleration == "QSV": # global_quality — аналог CRF для Intel QSV (ICQ режим) quality_flag, quality_value = "-global_quality", str(crf) elif acceleration in ("VAAPI", "AMF"): quality_flag, quality_value = "-qp", str(crf) else: quality_flag, quality_value = "-crf", str(crf) command = ["ffmpeg"] + hw_input_flags + [ "-i", file_path, "-map", "0:V", # main video only (excludes attached pics / cover art) "-map", "0:a?", # all audio streams "-map", "0:s?", # all subtitle streams (optional) "-c:v", codec, "-vf", vf, "-c:a", "copy", "-c:s", "copy", quality_flag, quality_value ] av1_vp9_codecs = ["libaom-av1", "av1_vaapi", "av1_amf", "av1_qsv", "libvpx-vp9", "vp9_vaapi"] if codec in av1_vp9_codecs: command.extend(["-cpu-used", str(cpu_used)]) elif acceleration == "NVENC": command.extend(["-preset", nvenc_preset_map.get(str(preset), "p4")]) elif acceleration == "AMF": command.extend(["-quality", amf_preset_map.get(str(preset), "balanced")]) elif acceleration in ("CPU", "QSV"): command.extend(["-preset", str(preset)]) # VAAPI: пресеты не поддерживаются, не добавляем command.append(output_file) return command def _run_ffmpeg_process(command, task, socketio, watch_cuda_error=False): """ Запускает ffmpeg, эмитит progress-события. Возвращает (process, output_tail, cuda_error_detected). Если watch_cuda_error=True и обнаружена ошибка CUDA-фильтра — немедленно завершает процесс и возвращает cuda_error_detected=True. """ process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) task["process"] = process output_tail = [] cuda_error_detected = False for line in process.stdout: output_tail.append(line.rstrip()) if len(output_tail) > 40: output_tail.pop(0) if watch_cuda_error and _NVENC_CUDA_FILTER_ERROR in line: cuda_error_detected = True process.terminate() break if "frame=" in line: socketio.emit('progress', { "task": { "id": task["id"], "file": task["file"], "command": task["command"] }, "message": line.strip() }) process.wait() return process, output_tail, cuda_error_detected def _copy_with_progress(src, dst, file_path, socketio, chunk_size=2 * 1024 * 1024): total = os.path.getsize(src) copied = 0 with open(src, 'rb') as fsrc, open(dst, 'wb') as fdst: while True: buf = fsrc.read(chunk_size) if not buf: break fdst.write(buf) copied += len(buf) percent = int(copied / total * 100) socketio.emit('copy-progress', {'file': file_path, 'percent': percent}) def transcode_file(transcoding_tasks, socketio, file_path, dest_path, acceleration, codec, resolution, crf, preset, cpu_used, operation_id=None, delete_original=False, user_id=None): # Phase 1: copy original to backup location if dest_path: os.makedirs(os.path.dirname(dest_path), exist_ok=True) socketio.emit('copy-progress', {'file': file_path, 'percent': 0}) _copy_with_progress(file_path, dest_path, file_path, socketio) base, ext = os.path.splitext(file_path) output_file = base + '_transcoded' + ext if os.path.exists(output_file): os.remove(output_file) # Для NVENC: сначала пробуем полный CUDA-пайплайн, при ошибке — CPU-scale fallback nvenc = (acceleration == "NVENC") command = get_ffmpeg_transcoding_cmd( file_path, acceleration, codec, resolution, crf, preset, cpu_used, output_file, _nvenc_full_cuda=nvenc ) fallback_command = get_ffmpeg_transcoding_cmd( file_path, acceleration, codec, resolution, crf, preset, cpu_used, output_file, _nvenc_full_cuda=False ) if nvenc else None print(" ".join(command)) task = { "id": "id_" + str(len(transcoding_tasks) + 1), "file": file_path, "output": output_file, "command": command, "process": None } transcoding_tasks[task["id"]] = task # Запуск с мониторингом CUDA-ошибки process, output_tail, cuda_error = _run_ffmpeg_process( command, task, socketio, watch_cuda_error=nvenc ) # CUDA-фильтр упал — переключаемся на CPU-scale и рестартуем if cuda_error and fallback_command: if os.path.exists(output_file): os.remove(output_file) print("NVENC CUDA filter error detected — retrying with CPU-assisted scaling") socketio.emit('progress', { "task": {"id": task["id"], "file": task["file"], "command": fallback_command}, "message": "CUDA pipeline failed — retrying with CPU-assisted scaling..." }) task["command"] = fallback_command process, output_tail, _ = _run_ffmpeg_process( fallback_command, task, socketio, watch_cuda_error=False ) # Step 3: Replace the original file with the transcoded file file_name = os.path.basename(file_path) if process.returncode == 0: os.replace(output_file, file_path) if operation_id: update_operation(operation_id, "completed") fresh_info = get_media_info_with_ffprobe(file_path) if fresh_info: update_file_media_info(file_path, os.path.getsize(file_path), fresh_info) db_file = get_file_by_path(file_path) if db_file: invalidate_thumbs(db_file["id"]) if delete_original: op = get_operation_by_id(operation_id) if op and op.get("backup_path") and os.path.exists(op["backup_path"]): os.remove(op["backup_path"]) mark_backup_deleted(operation_id) stats = calculate_and_save_stats() notify(socketio, user_id, "success", f"Transcoding complete: {file_name}", f"Codec: {codec} · Acceleration: {acceleration}") socketio.emit('completed', { "task": { "id": task["id"], "file": task["file"], "command": task["command"] }, "message": f"File {file_path} transcoded successfully", "stats": stats }) del transcoding_tasks[task["id"]] else: if task["id"] in transcoding_tasks: if operation_id: update_operation(operation_id, "failed") ffmpeg_log = "\n".join(output_tail[-20:]) if output_tail else "" notify(socketio, user_id, "error", f"Transcoding failed: {file_name}", ffmpeg_log or None) socketio.emit('error', { "task": { "id": task["id"], "file": task["file"], "command": task["command"] }, "message": f"Transcoding failed for {file_path}", "ffmpeg_log": ffmpeg_log }) del transcoding_tasks[task["id"]] else: if operation_id: update_operation(operation_id, "canceled") socketio.emit('canceled', { "task": { "id": task["id"], "file": task["file"], "command": task["command"] }, "message": f"Transcoding canceled for {file_path}" }) if os.path.exists(output_file): os.remove(output_file)