Vapoursynth视频压制笔记

1
import argparse
2
import json
3
from pathlib import Path
4
import os
5

6
def find_bd_root(parent_path: Path) -> Path | None:
7
    """
8
    在给定的父路径下，查找包含 BDMV 文件夹的子目录（即蓝光根目录）。
9
    只查找一层深度。
10
    """
11
    if not parent_path.is_dir():
12
        return None
13

14
    for item in parent_path.iterdir():
15
        if item.is_dir():
16
            if (item / "BDMV").is_dir():
17
                return item
18
            elif (item.name in ["BDMV", "bdmv"]) and (item.is_dir()):
19
                return parent_path
20

21
    return None
22

23
def find_largest_m2ts(bd_root_path: Path) -> Path | None:
24
    """
25
    在给定的 BD 根目录下，查找 BDMV/STREAM/ 文件夹中最大的 .m2ts 文件。
26
    """
27
    stream_dir = bd_root_path / "BDMV" / "STREAM"
28

29
    if not stream_dir.is_dir():
30
        return None
31
    m2ts_files = list(stream_dir.glob("*.m2ts"))
32

33
    if not m2ts_files:
34
        print(f"  -> 警告: 在 '{stream_dir}' 中未找到任何 .m2ts 文件。")
35
        return None
36

37
    return max(m2ts_files, key=lambda p: p.stat().st_size)
38

39
def find_main_video_file(parent_path: Path) -> Path | None:
40
    """
41
    智能地在给定目录中查找主视频文件。
42
    优先级: BDMV -> MKV (递归) -> MP4 (递归)
43
    """
44
    # 策略 1: 查找 BDMV 结构 (非递归)
45
    bd_root = find_bd_root(parent_path)
46
    if bd_root:
47
        print(f"  -> 检测到 BDMV 结构，位于: {bd_root}")
48
        return find_largest_m2ts(bd_root)
49
    # 策略 2: 按优先级递归查找其他容器格式
50
    print("  -> 未检测到 BDMV 结构，开始递归查找其他视频文件...")
51
    for ext in ["mkv", "mp4"]:
52
        print(f"  -> 正在递归搜索 .{ext} 文件...")
53
        files = list(parent_path.glob(f"**/*.{ext}"))
54

55
        if files:
56
            largest_file = max(files, key=lambda p: p.stat().st_size)
57
            relative_path = largest_file.relative_to(parent_path)
58
            print(f"  -> 找到最大的 {ext.upper()} 文件: {relative_path}")
59
            return largest_file
60
        else:
61
            print(f"  -> 目录中未找到任何 .{ext} 文件。")
62

63
    return None
64

65
def generate_vpy_snippet(var_name: str, video_path: Path) -> tuple[str, str]:
66
    """
67
    根据变量名和视频文件路径生成 VapourSynth 代码片段。
68
    返回 (代码片段, 使用的安全变量名)。
69
    """
70
    absolute_path = os.path.abspath(video_path)
71
    # 确保变量名在VapourSynth中有效
72
    safe_var_name = var_name.replace('-', '_').replace('.', '_')
73

74
    source_line = f'{safe_var_name} = core.lsmas.LWLibavSource(r"{absolute_path}")'
75
    fps_line = f'{safe_var_name} = core.std.AssumeFPS({safe_var_name}, fpsnum=24000, fpsden=1001)'
76
    depth_line = f'{safe_var_name} = mvf.Depth({safe_var_name}, 16)'
77

78
    snippet = f"{source_line}\n{fps_line}\n{depth_line}"
79
    return snippet, safe_var_name
80

81
def main():
82
    """主执行函数"""
83
    parser = argparse.ArgumentParser(
84
        description="自动扫描指定目录下的所有子文件夹，查找主视频文件(BDMV/MKV/MP4)，并生成VapourSynth代码追加到.vpy文件中。"
85
    )
86
    parser.add_argument("compare_vpy_file", help="要修改的目标 .vpy 文件路径")
87
    parser.add_argument(
88
        "source_directory",
89
        help="包含多个BD或Remux子文件夹的源目录 (e.g., 'silver/bd')"
90
    )
91
    args = parser.parse_args()
92
    vpy_file = Path(args.compare_vpy_file)
93
    if not vpy_file.exists():
94
        print(f"信息: vpy 文件 '{vpy_file}' 不存在，将自动创建。")
95
        vpy_file.touch()
96
    source_dir = Path(args.source_directory)
97
    if not source_dir.is_dir():
98
        print(f"错误: 源目录 '{source_dir}' 不存在或不是一个目录。")
99
        return
100
    sub_directories = sorted([d for d in source_dir.iterdir() if d.is_dir()])
101

102
    print(f"将在 '{source_dir}' 目录下扫描 {len(sub_directories)} 个子文件夹...")
103
    generated_snippets = []
104
    successful_vars = [] # <--- 新增：用于存储成功生成的安全变量名
105

106
    for sub_dir in sub_directories:
107
        print(f"\n--- 正在处理: {sub_dir} ---")
108

109
        main_video = find_main_video_file(sub_dir)
110

111
        if main_video:
112
            var_name = sub_dir.name.upper()
113

114
            # 生成代码片段，并获取使用到的安全变量名
115
            snippet, safe_name = generate_vpy_snippet(var_name, main_video)
116

117
            print(f"最终找到的主视频文件: {main_video}")
118
            print(f"将使用变量名: {safe_name}")
119

120
            generated_snippets.append(snippet)
121
            successful_vars.append(safe_name) # <--- 新增：记录变量名
122
        else:
123
            print(f"警告: 在 '{sub_dir}' 下未找到支持的视频文件 (BDMV/MKV/MP4)，已跳过。")
124

125
    if not generated_snippets:
126
        print("\n没有生成任何代码片段，vpy 文件未被修改。")
127
        return
128

129
    # --- 新增：生成 FrameInfo 和 set_output 代码块 ---
130
    frame_info_lines = []
131
    set_output_lines = []
132
    for i, var in enumerate(successful_vars):
133
        frame_info_lines.append(f"{var} = awf.FrameInfo({var}, '{var}')")
134
        set_output_lines.append(f"{var}.set_output({i})")
135

136
    all_new_code = "\n\n".join(generated_snippets)
137
    frame_info_code = "\n".join(frame_info_lines)
138
    set_output_code = "\n".join(set_output_lines)
139
    # --- 结束新增部分 ---
140

141
    try:
142
        fixed_import = """import vapoursynth as vs
143
import awsmfunc as awf
144
import kagefunc as kgf
145
import mvsfunc as mvf
146
import adptvgrnMod
147
from rekt import rektlvls
148
from vsutil import get_y
149
from screenshot import GetSnapShot, upload_to_lsky_album
150
core = vs.core\n"""
151

152
        original_content = ""
153
        # 只有在文件存在且不为空时才读取
154
        if vpy_file.exists() and vpy_file.stat().st_size > 0:
155
            original_content = vpy_file.read_text(encoding='utf-8')
156
            # 如果原始文件已有import，避免重复添加
157
            if original_content.strip().startswith("import vapoursynth"):
158
                fixed_import = ""
159

160
        # 拼接所有部分
161
        new_content = (
162
            fixed_import +
163
            original_content.strip() +
164
            "\n\n# --- 自动生成的源滤镜代码 ---\n" +
165
            all_new_code +
166
            "\n\n# --- 自动生成的 FrameInfo 和 Output ---\n" +
167
            frame_info_code +
168
            "\n\n" +
169
            set_output_code +
170
            "\n\n# --- 自动生成的代码结束 ---\n"
171
        )
172

173
        vpy_file.write_text(new_content, encoding='utf-8')
174
        print(f"\n成功！已将生成的代码追加到 '{vpy_file}' 的末尾。")
175

176
    except IOError as e:
177
        print(f"错误: 读写文件 '{vpy_file}' 时发生错误: {e}")
178
    except Exception as e:
179
        print(f"发生未知错误: {e}")
180

181
if __name__ == "__main__":
182
    main()

1
import argparse
2
import json
3
from pathlib import Path
4
import os
5
import subprocess
6
import sys
7
import time
8

9
def main(vpy_file, crf_value, zone, total_frames, output_path):
10
    start_time = time.time()
11
    # ... (命令定义部分保持不变) ...
12
    vspipe_cmd = ['vspipe', '-c', 'y4m', vpy_file, '-']
13
    x264_cmd = [
14
        'x264',
15
        '--output-depth', '8',
16
        '--crf', str(crf_value),
17
        '--preset', 'veryslow',
18
        '--profile', 'high',
19
        '--level', '4.1',
20
        '--vbv-bufsize', '78125',
21
        '--vbv-maxrate', '62500',
22
        '--merange', '32',
23
        '--bframes', '16',
24
        '--deblock', '-3:-3',
25
        '--no-fast-pskip',
26
        '--rc-lookahead', '250',
27
        '--qcomp', '0.60',
28
        '--psy-rd', '1.0:0.00',
29
        '--aq-mode', '3',
30
        '--aq-strength', '0.75',
31
        '--me', 'umh',
32
        '--b-adapt', '2',
33
        '--direct', 'auto',
34
        '--subme', '11',
35
        '--trellis', '2',
36
        '--no-dct-decimate',
37
        '--no-mbtree',
38
        '--colormatrix', 'bt709',
39
        '--colorprim', 'bt709',
40
        '--transfer', 'bt709',
41
        '--ipratio', '1.30',
42
        '--pbratio', '1.20',
43
        '--output', output_path,
44
        '--frames', str(total_frames),
45
        '--demuxer', 'y4m',
46
        '-'
47
    ]
48
    if zone:
49
        tmp = []
50
        for z in zone:
51
            tmp.append(f"{z[0]},{z[1]},b=1.3")
52
        output_index = x264_cmd.index('--output')
53
        x264_cmd.insert(output_index, '--zones')
54
        x264_cmd.insert(output_index + 1, '/'.join(tmp))
55

56
    # --- 优化后的执行与日志记录模块 ---
57
    log_file_path = Path(output_path).with_suffix('.txt')
58
    full_command_str = ' '.join(vspipe_cmd) + ' | ' + ' '.join(x264_cmd)
59
    print(f'--------------------------- CRF {crf_value} begin ---------------------------')
60
    print(f"执行命令: {full_command_str}")
61
    print(f"输出文件: {output_path}")
62
    print(f"日志文件: {log_file_path}")
63

64
    try:
65
        with open(log_file_path, 'w', encoding='utf-8') as log_file:
66
            # --- 新增功能：将命令写入日志文件顶部 ---
67
            # log_file.write(f"--- Command for CRF {crf_value} ---\n")
68
            log_file.write(full_command_str + "\n")
69
            # log_file.write("--- Log Output ---\n")
70
            # --- 新增功能结束 ---
71

72
            vspipe_process = subprocess.Popen(vspipe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
73
            x264_process = subprocess.Popen(
74
                x264_cmd,
75
                stdin=vspipe_process.stdout,
76
                stdout=subprocess.PIPE,
77
                stderr=subprocess.STDOUT,
78
                text=True,
79
                encoding='utf-8',
80
                errors='replace'
81
            )
82
            vspipe_process.stdout.close()
83

84
            for line in iter(x264_process.stdout.readline, ''):
85
                # **新的、更可靠的进度行判断逻辑**
86
                # 进度行通常以 '[' 开头，并包含 'fps' 和 'eta'
87
                line_stripped = line.strip()
88
                if line_stripped.startswith('[') and 'fps' in line_stripped and 'eta' in line_stripped:
89
                    # 这是进度行，我们在控制台动态刷新它
90
                    sys.stdout.write(" " * 80 + "\r") # 清除旧行内容
91
                    sys.stdout.write(line_stripped + '\r')
92
                    sys.stdout.flush()
93
                    # 并且，我们不把它写入日志文件
94
                else:
95
                    # 这是永久信息行 (如 x264 [info] 或最终总结)
96
                    # 在控制台正常打印
97
                    print(line_stripped)
98
                    # 并把它写入日志文件
99
                    log_file.write(line)
100

101
            print() # 进度条结束后换行，保持终端整洁
102

103
            # 等待进程结束
104
            vspipe_process.wait()
105
            x264_process.wait()
106

107
            # **新的、更智能的错误处理逻辑**
108
            # 如果 x264 成功退出，那么 vspipe 的 SIGPIPE(-13) 错误是正常的，可以忽略
109
            if x264_process.returncode == 0 and vspipe_process.returncode in [-13, 141]: # 141 is 128+13, another way SIGPIPE is reported
110
                print("VSPipe 进程被正常中止 (SIGPIPE)，这是预期行为。")
111
            elif vspipe_process.returncode != 0:
112
                # 只有在 x264 也失败，或者 vspipe 报了其他错误时，才报告 vspipe 错误
113
                vspipe_stderr = vspipe_process.stderr.read().decode('utf-8', errors='replace')
114
                error_message = f"VSPipe 错误 (返回码: {vspipe_process.returncode}):\n{vspipe_stderr}"
115
                print(error_message)
116
                log_file.write(f"\n\n--- VSPipe Error ---\n{error_message}\n")
117

118
            if x264_process.returncode != 0:
119
                print(f"x264 编码失败，返回码: {x264_process.returncode}")
120
            else:
121
                print(f"nCRF {crf_value} 编码成功!")
122

123
    except FileNotFoundError:
124
        print("错误: 'vspipe' 或 'x264' 命令未找到。请确保它们已安装并在系统 PATH 中。")
125
    except Exception as e:
126
        print(f"发生未知错误: {e}")
127

128
    print(f'--------------------------- CRF {crf_value} End (Time: {time.time() - start_time:.2f} 秒) -----------------------------')
129
    print("\n")
130

131
# __main__ 部分保持不变
132
if __name__ == "__main__":
133
    parser = argparse.ArgumentParser(description="视频处理脚本")
134
    # ... 其余部分完全相同 ...
135
    parser.add_argument("vpy_file", help="输入的 vpy 文件路径")
136
    parser.add_argument("crf_value", type=json.loads, help="CRF 值 (JSON 格式的数组, e.g., '[18, 18.5]')")
137
    parser.add_argument("zone", type=json.loads, help="Zone 值 (JSON 格式的数组, e.g., '[[103,543], [1000,2000]]')")
138
    parser.add_argument("total_frames", type=int, help="视频总帧数")
139
    parser.add_argument("output_path", help="输出文件目录")
140
    args = parser.parse_args()
141

142
    vpy_path = Path(args.vpy_file)
143
    if not vpy_path.exists():
144
        print(f"错误: vpy 文件不存在 -> {vpy_path}")
145
        exit(1)
146
    if not vpy_path.name.endswith(".vpy"):
147
        print("错误: 输入文件不是 vpy 文件")
148
        exit(1)
149

150
    output_dir = Path(args.output_path)
151
    output_dir.mkdir(parents=True, exist_ok=True)
152

153
    vpy_file_path = str(vpy_path.resolve())
154
    output_dir_path = str(output_dir.resolve())
155

156
    for i in args.crf_value:
157
        output_file = Path(output_dir_path) / f"crf{i}.mkv"
158
        if (output_file.exists()):
159
            # 删除已存在的文件和日志
160
            os.remove(output_file)
161
            log_file = output_file.with_suffix('.txt')
162
            if log_file.exists():
163
                os.remove(log_file)
164
        main(vpy_file_path, i, args.zone, args.total_frames, str(output_file))
165

166
    # 把所有log文件合并成一个，之间添加三行换行
167
    combined_log_path = output_dir / "combined_log.txt"
168
    if len(args.crf_value) > 0:
169
        with open(combined_log_path, 'a', encoding='utf-8') as combined_log:
170
            for i in args.crf_value:
171
                log_file = output_dir / f"crf{i}.txt"
172
                if log_file.exists():
173
                    with open(log_file, 'r', encoding='utf-8') as lf:
174
                        combined_log.write(lf.read())
175
                        combined_log.write("\n\n\n") # 三行换行分隔
176
                # 删除文件
177
                if log_file.exists():
178
                    os.remove(log_file)
179
        print(f"所有日志已合并到 {combined_log_path}")

1
import os
2
import srt
3
import time
4
import argparse
5
import concurrent.futures
6
from openai import OpenAI
7
from pathlib import Path
8
from tqdm import tqdm
9

10
# --- 配置 ---
11
# 建议使用环境变量，但也可以直接在此处设置 API 密钥
12
API_KEY = "xxxxxx"
13
# API_KEY = os.getenv("OPENAI_API_KEY")
14
BASE_URL = 'https://api.openai.com/v1'  # 如果使用自定义的 OpenAI 兼容 API，请修改此处
15
MODEL_NAME = "gemini-2.5-pro"
16
CHUNK_SIZE = 100       # 每次处理的字幕数量
17
MAX_WORKERS = 50           # 并行请求的数量，可根据你的 API 速率限制调整
18
SYSTEM_PROMPT = """
19
You are an expert proofreader and editor specializing in UK English. Your task is to correct spelling, grammar, and punctuation errors in the provided SRT subtitle block that are ocr'd from a .sup file. Especially focus on `i`, `l`, 'I`, 'L` chaos.
20

21
Follow these rules STRICTLY:
22
1.  **Target Language**: All corrections must adhere to standard UK English (e.g., use 'colour', not 'color'; 'realise', not 'realize'; 'dialogue', not 'dialog').
23
2.  **Preserve Structure**: You MUST return the corrected text in the exact same SRT format. This includes preserving all subtitle index numbers, timestamps, formatting tag, and line breaks within the text. DO NOT alter, add, or remove any timestamps or index numbers.
24
3.  **Content Focus**: Only modify the subtitle text itself for corrections. If a line of text is already correct, leave it unchanged.
25
4.  **No Extra Commentary**: Do not add any explanations, apologies, or comments before or after the SRT block. Your entire response must be ONLY the corrected SRT data.
26
5.  Do not change any names, places, or specific terminology unless they are clearly misspelled.
27

28
Here is an example of the required input and output format:
29

30
--- EXAMPLE INPUT ---
31
3
32
00:00:19,895 --> 00:00:22,273
33
<i>The whole famlly's together.</i>
34
<i>Mom makes braciole.</i>
35

36
4
37
00:00:22,440 --> 00:00:25,276
38
<i>Dad puts the jersey on.</i>
39
<i>We're aiI watchlng the game.</i>
40

41

42
--- EXAMPLE OUTPUT ---
43
3
44
00:00:19,895 --> 00:00:22,273
45
<i>The whole family's together.</i>
46
<i>Mom makes braciole.</i>
47

48
4
49
00:00:22,440 --> 00:00:25,276
50
<i>Dad puts the jersey on.</i>
51
<i>We're all watching the game.</i>
52

53
"""
54

55
def correct_chunk_task(client: OpenAI, srt_chunk_string: str, chunk_index: int):
56
    """
57
    单个并行任务：调用 OpenAI API 校对一个 SRT 块。
58
    返回一个元组 (chunk_index, corrected_srt_string)。
59
    """
60
    try:
61
        response = client.chat.completions.create(
62
            model=MODEL_NAME,
63
            messages=[
64
                {"role": "system", "content": SYSTEM_PROMPT},
65
                {"role": "user", "content": f"Now, please process the following SRT block:\n\n{srt_chunk_string}"}
66
            ],
67
            temperature=0.1,
68
        )
69
        corrected_text = response.choices[0].message.content.strip()
70
        return chunk_index, corrected_text
71
    except Exception as e:
72
        # 如果 API 调用失败，打印错误并返回 None，以便主线程可以处理回退
73
        print(f"\nError processing chunk {chunk_index + 1}: {e}")
74
        return chunk_index, None
75

76
def process_srt_file(input_path, output_path, max_workers):
77
    """
78
    使用并行处理读取、校对并保存 SRT 文件。
79
    """
80
    if not API_KEY:
81
        print("Error: OPENAI_API_KEY environment variable not set.")
82
        return
83

84
    try:
85
        with open(input_path, 'r', encoding='utf-8') as f:
86
            content = f.read()
87
        original_subs = list(srt.parse(content))
88
        print(f"Successfully loaded {len(original_subs)} subtitles from '{input_path}'.")
89
    except Exception as e:
90
        print(f"Error reading or parsing SRT file: {e}")
91
        return
92

93
    # 将字幕分割成块
94
    chunks_of_subs = [original_subs[i:i + CHUNK_SIZE] for i in range(0, len(original_subs), CHUNK_SIZE)]
95
    total_chunks = len(chunks_of_subs)
96
    print(f"Divided into {total_chunks} chunks for processing with up to {max_workers} parallel workers.")
97

98
    client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
99

100
    # 创建一个列表来按顺序存储结果
101
    corrected_results = [None] * total_chunks
102

103
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
104
        # 提交所有任务
105
        future_to_chunk = {
106
            executor.submit(correct_chunk_task, client, srt.compose(chunk), i): chunk
107
            for i, chunk in enumerate(chunks_of_subs)
108
        }
109

110
        # 使用 tqdm 创建进度条，当任务完成时更新
111
        progress_bar = tqdm(concurrent.futures.as_completed(future_to_chunk), total=total_chunks, desc="Correcting Chunks")
112

113
        for future in progress_bar:
114
            original_chunk = future_to_chunk[future]
115
            try:
116
                index, corrected_srt_string = future.result()
117

118
                if corrected_srt_string:
119
                    # 验证返回的 SRT 是否有效
120
                    try:
121
                        corrected_chunk_subs = list(srt.parse(corrected_srt_string))
122
                        if len(corrected_chunk_subs) != len(original_chunk):
123
                            print(f"\nWarning: Mismatch in subtitle count for chunk {index + 1}. Using original.")
124
                            corrected_results[index] = original_chunk # 回退到原始块
125
                        else:
126
                            corrected_results[index] = corrected_chunk_subs
127
                    except Exception as parse_error:
128
                        print(f"\nError parsing corrected SRT for chunk {index + 1}: {parse_error}. Using original.")
129
                        corrected_results[index] = original_chunk # 回退到原始块
130
                else:
131
                    # API 调用失败，使用原始块
132
                    corrected_results[index] = original_chunk
133

134
            except Exception as exc:
135
                # 任务本身抛出异常
136
                print(f"\nA task generated an exception: {exc}. The original chunk will be used.")
137
                # 找到这个异常 future 对应的索引并回退
138
                for f, c in future_to_chunk.items():
139
                    if f == future:
140
                        # 这是个笨办法，但能用。更好的方法是在提交时就把索引和future关联起来
141
                        # (我们已经在 correct_chunk_task 返回值里做了，这里是双保险)
142
                        for i, chunk_list in enumerate(chunks_of_subs):
143
                            if chunk_list == c:
144
                                corrected_results[i] = chunk_list
145
                                break
146
                        break
147

148
    # 组合所有处理过的块
149
    final_subs = []
150
    for chunk in corrected_results:
151
        if chunk:
152
            final_subs.extend(chunk)
153

154
    try:
155
        final_srt_content = srt.compose(final_subs)
156
        with open(output_path, 'w', encoding='utf-8') as f:
157
            f.write(final_srt_content)
158
        print(f"\nProcessing complete. Corrected subtitles saved to '{output_path}'.")
159
    except Exception as e:
160
        print(f"\nError writing the final SRT file: {e}")
161

162
if __name__ == "__main__":
163
    parser = argparse.ArgumentParser(description="Correct spelling and grammar in an SRT file using OpenAI in parallel.")
164
    parser.add_argument("input_file", type=str, help="The path to the input SRT file.")
165
    parser.add_argument("-o", "--output_file", type=str, help="The path to save the corrected SRT file. Defaults to 'input_filename_corrected.srt'.")
166
    parser.add_argument("-w", "--workers", type=int, default=MAX_WORKERS, help=f"Number of parallel requests to send to OpenAI. Default: {MAX_WORKERS}.")
167

168
    args = parser.parse_args()
169

170
    input_path = Path(args.input_file)
171
    if not input_path.is_file():
172
        print(f"Error: Input file not found at '{input_path}'")
173
    else:
174
        if args.output_file:
175
            output_path = Path(args.output_file)
176
        else:
177
            output_path = input_path.with_name(f"{input_path.stem}_corrected{input_path.suffix}")
178

179
        process_srt_file(str(input_path), str(output_path), args.workers)

1
import vapoursynth as vs
2
import awsmfunc as awf
3
import kagefunc as kgf
4
import mvsfunc as mvf
5
import adptvgrnMod
6
from rekt import rektlvls
7
from vsutil import get_y
8
from screenshot import GetSnapShot
9
core = vs.core
10

11

12
source = core.lsmas.LWLibavSource('/demux/complete/Return/extract/video.h264').std.Crop(0, 0, 20, 20)
13
source = awf.fb(source, top=1, bottom=1, mode='fillmargins')
14
source = awf.zresize(source, top=1, bottom=1)
15
source = core.std.AssumeFPS(source, fpsnum=24000, fpsden=1001)
16
source = mvf.Depth(source, 16)
17

18
# src.set_output()
19
awf.banddtct(source,thr=100,min_zone_len=20)