Crash is run with 1 worker reports speed <1

[zwogorg]

Classifications

• Running python ./jellybench_py/hwi.py manually (within the Poetry shell) works and produces correct results.
• This happens on a Virtual Hardware (VM, WSL, ...)
• The issue occurs during the benchmark section of the script (after Starting Benchmark...).
• A server issue or faulty server response is causing the problem.
• jellybench was run in --debug mode (recommended for issue reports).
• I am using the latest version (branch develop) of jellybench. I understand older versions are not supported.

Description

Hi,

I'm testing Jellybench on various systems. If the system can't handle a run with a speed of >= 1 Jellybench crashes with the following error:

Error Code or Output

> > > > Failed: ['performance']
| > > Current Test: 2160p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg -c:v h264 -i /home/redacted/jellybench_py/jellybench_data/videos/Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,528)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 0.99
| > > > > Failed: ['limited']
Traceback (most recent call last):
  File "/home/redacted/jellybench_py/bin/jellybench", line 6, in <module>
    sys.exit(main())
             ^^^^^^
  File "/home/redacted/jellybench_py/jellybench_py/core.py", line 1045, in main
    return cli()
           ^^^^^
  File "/home/redacted/jellybench_py/jellybench_py/core.py", line 998, in cli
    valid, runs, result = benchmark(
                          ^^^^^^^^^^
  File "/home/redacted/jellybench_py/jellybench_py/core.py", line 360, in benchmark
    "single_worker_speed": max_pass_run_data["speed"],
                           ~~~~~~~~~~~~~~~~~^^^^^^^^^
KeyError: 'speed'

Steps to Reproduce

Run Jellybench on a system that can't handle cpu intensive transcoding tasks

Operating System

Linux

System Architecture

x86_64 (64-bit)

Python Version

3.12.3

CPU[s]

Intel(R) Core(TM) i5-7500T CPU @ 2.70GHz

GPU[s]

Intel HD Graphics 630

Additional Context

No response

Possible Solution

Hotfix is to set "speed" and "rss_kb"to 0 if not set. Don't know how the API will handle this, though. Change line 360 and 361 in core.py from

"single_worker_speed": max_pass_run_data["speed"],
"single_worker_rss_kb": max_pass_run_data["rss_kb"],

to

    "single_worker_speed": max_pass_run_data.get("speed", 0),
    "single_worker_rss_kb": max_pass_run_data.get("rss_kb", 0),

[BotBlake]

Hi there,
sorry for the super late response.
I have not been actively working on this tool the past few months - but now I am looking into it again!

I am not entirely sure, but I assume this is related to the ffmpeg issues I am trying to deal with.
Sometimes ffmpeg does not report back numbers.
This can either be "N/A" like here: #70
Or just no value whatsoever: #86

I made a branch a while ago to try narrowing that issue down!
If you want to help development, feel free to try out this branch:
#94

There also is an open PR that sets the values to 0 - just like you proposed!
#87
I commented on there why I don't think that is a feasible approach here.

Basically it comes down to: We need those values and cant just set them to zero.

[josephyooo]

I'm getting the same problem.

Classifications

Same as above

Error Output

E:\jellybench_py>uv run jellybench --debug

Welcome to jellybench_py Cheeseburger Edition 🍔

Disclaimer
| Please close all background programs and plug the device into a power source if it is running on battery
| power before starting the benchmark.
Continue (y/n): y

Dev Mode : Special Features and Output enabled DO NOT UPLOAD RESULTS!

System Initialization
| Supported Platforms:
| IDX: Name - Type - Architecture
| > [0]: Windows 11 - Windows - amd64
| > [1]: Linux Generic - Linux - amd64
| > [2]: Mac OS Darwin - Mac - amd64
| > [3]: Mac OS Darwin - Mac - arm64
| > [4]: Windows 10 - Windows - amd64
| > [5]: Ubuntu Focal - Linux - amd64
| > [6]: Linux Generic - Linux - arm64
| Selecting Platform... success!
| Obtaining System Information... success!
| Detected System Config:
|   OS: Windows 11
|   CPU: AMD Ryzen 5 2600 Six-Core Processor
|     Threads: 12
|     Arch: AMD64
|   RAM:
|     - Unknown 8 gigabytes 8
|     - Unknown 8 gigabytes 8
|   GPU(s):
|     1: NVIDIA GeForce GTX 1060 6GB
Done

Loading ffmpeg
| Searching local "ffmpeg" -FilePath: E:\jellybench_py\jellybench_data\ffmpeg\jellyfin-ffmpeg_5.1.4-3-portable_win64.zip

| > Target File Path: E:\jellybench_py\jellybench_data\ffmpeg\jellyfin-ffmpeg_5.1.4-3-portable_win64.zip
 success!
Note: Compatible hashing method found. Using sha256
INFO: Replacing existing files with validated ones.
Unpacking Archive... success!
Obtaining Test-Files:
| "Test Jellyfin 1080p AVC 30M.mp4" - local -FilePath: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%201080p%20AVC%2030M.mp4

| > Target File Path: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%201080p%20AVC%2030M.mp4
 success!
| "Test Jellyfin 4K HEVC 10bit 40M.mp4" - local -FilePath: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4

| > Target File Path: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4
 success!
| "Test Jellyfin 4K AVC 150M.mp4" - local -FilePath: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20AVC%20150M.mp4

| > Target File Path: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20AVC%20150M.mp4
 success!
| "Test Jellyfin 4K HEVC 10bit 150M" - local -FilePath: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20HEVC%2010bit%20150M.mp4

| > Target File Path: E:\jellybench_py\jellybench_data\videos\Test%20Jellyfin%204K%20HEVC%2010bit%20150M.mp4
 success!
Done

Testing for driver limits: (NVIDIA)
| Your driver (581.42) should only allow 8 NvEnc sessions
| Testing with 9 workers... limited!
| > Your GPU driver does only allow 8 concurrent NvEnc sessions!
| > Do you want to skip GPU tests? (y/N): n
Done

We will do 144 tests.
Continue (y/n): y


| Current File: Test Jellyfin 1080p AVC 30M.mp4
| > > Current Test: 1080p - 720p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.25
| > > > > Starting run with 8 Workers... completed with speed 1.72
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.51
| > > > > Starting run with 11 Workers... completed with speed 0.95
| > > > > Starting run with 10 Workers... completed with speed 1.15
| > > > > Test Finished, Max Pass: 10, Min Fail: 11
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 2160p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.40
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.11
| > > > > Starting run with 11 Workers... completed with speed 1.06
| > > > > Starting run with 12 Workers... completed with speed 0.97
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 720p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.27
| > > > > Starting run with 5 Workers... completed with speed 1.75
| > > > > Starting run with 9 Workers... completed with speed 0.97
| > > > > Starting run with 8 Workers... completed with speed 1.06
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.68
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > Current Test: 720p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.61
| > > > > Starting run with 5 Workers... completed with speed 1.75
| > > > > Starting run with 9 Workers... completed with speed 0.96
| > > > > Starting run with 8 Workers... completed with speed 1.09
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.16
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > Current Test: 2160p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.63
| > > > > Starting run with 5 Workers... completed with speed 1.76
| > > > > Starting run with 9 Workers... completed with speed 0.94
| > > > > Starting run with 8 Workers... completed with speed 1.07
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.70
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > Current Test: 2160p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.59
| > > > > Starting run with 5 Workers... completed with speed 1.74
| > > > > Starting run with 9 Workers... completed with speed 0.97
| > > > > Starting run with 8 Workers... completed with speed 1.09
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.44
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > Current Test: 720p - 720p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.18
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 8.01
| > > > > Starting run with 9 Workers... completed with speed 1.20
| > > > > Starting run with 11 Workers... completed with speed 1.01
| > > > > Starting run with 12 Workers... completed with speed 0.95
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 2160p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.32
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.48
| > > > > Starting run with 11 Workers... completed with speed 1.07
| > > > > Starting run with 12 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.42
| > > > > Starting run with 5 Workers... completed with speed 1.73
| > > > > Starting run with 9 Workers... completed with speed 0.97
| > > > > Starting run with 8 Workers... completed with speed 1.04
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.75
| > > > > Starting run with 8 Workers... completed with speed 1.72
| > > > > Failed: ['limited']
| > > Current Test: 1080p - 1080p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.36
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.74
| > > > > Starting run with 11 Workers... completed with speed 1.07
| > > > > Starting run with 12 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 720p - 2160p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.62
| > > > > Starting run with 8 Workers... completed with speed 1.71
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 8.79
| > > > > Starting run with 9 Workers... completed with speed 1.22
| > > > > Starting run with 12 Workers... completed with speed 0.93
| > > > > Starting run with 11 Workers... completed with speed 1.06
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 720p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.12
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.26
| > > > > Starting run with 11 Workers... completed with speed 1.06
| > > > > Starting run with 12 Workers... completed with speed 0.98
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.57
| > > > > Starting run with 5 Workers... completed with speed 1.74
| > > > > Starting run with 9 Workers... completed with speed 0.97
| > > > > Starting run with 8 Workers... completed with speed 1.09
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 11.57
| > > > > Starting run with 8 Workers... completed with speed 1.71
| > > > > Failed: ['limited']
| > > Current Test: 720p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.61
| > > > > Starting run with 5 Workers... completed with speed 1.73
| > > > > Starting run with 9 Workers... completed with speed 0.97
| > > > > Starting run with 8 Workers... completed with speed 1.09
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.94
| > > > > Starting run with 8 Workers... completed with speed 1.71
| > > > > Failed: ['limited']
| > > Current Test: 720p - 1080p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 13.22
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.07
| > > > > Starting run with 11 Workers... completed with speed 1.06
| > > > > Starting run with 12 Workers... completed with speed 0.97
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 1080p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.15
| > > > > Starting run with 8 Workers... completed with speed 1.72
| > > > > Failed: ['limited']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 10.18
| > > > > Starting run with 11 Workers... completed with speed 1.04
| > > > > Starting run with 12 Workers... completed with speed 0.95
| > > > > Test Finished, Max Pass: 11, Min Fail: 12
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.43
| > > > > Starting run with 5 Workers... completed with speed 1.65
| > > > > Starting run with 9 Workers... completed with speed 0.95
| > > > > Starting run with 8 Workers... completed with speed 1.07
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.77
| > > > > Starting run with 8 Workers... completed with speed 1.70
| > > > > Failed: ['limited']
| > > Current Test: 1080p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,106)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 4.58
| > > > > Starting run with 5 Workers... completed with speed 1.69
| > > > > Starting run with 9 Workers... completed with speed 0.93
| > > > > Starting run with 8 Workers... completed with speed 1.06
| > > > > Test Finished, Max Pass: 8, Min Fail: 9
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%201080p%20AVC%2030M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:106:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 12.20
| > > > > Starting run with 8 Workers... completed with speed 1.71
| > > > > Failed: ['limited']

| Current File: Test Jellyfin 4K HEVC 10bit 40M.mp4
| > > Current Test: 2160p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.82
| > > > > Starting run with 2 Workers... completed with speed 0.94
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.84
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.89
| > > > > Starting run with 2 Workers... completed with speed 0.94
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.95
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.64
| > > > > Starting run with 2 Workers... completed with speed 0.89
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.33
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.62
| > > > > Starting run with 2 Workers... completed with speed 0.89
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.49
| > > > > Starting run with 2 Workers... completed with speed 0.89
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.33
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.64
| > > > > Starting run with 2 Workers... completed with speed 0.89
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.89
| > > > > Starting run with 2 Workers... completed with speed 0.97
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.97
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.90
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.63
| > > > > Starting run with 2 Workers... completed with speed 0.91
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.89
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.33
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.64
| > > > > Starting run with 2 Workers... completed with speed 0.91
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 1.00
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 1080p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.33
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.65
| > > > > Starting run with 2 Workers... completed with speed 0.91
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.89
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.64
| > > > > Starting run with 2 Workers... completed with speed 0.90
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 2160p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.90
| > > > > Starting run with 2 Workers... completed with speed 0.96
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v h264_nvenc -preset p1 -b:v 79616000 -maxrate 79616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.88
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.33
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v hevc -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,141)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.65
| > > > > Starting run with 2 Workers... completed with speed 0.90
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v hevc_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20HEVC%2010bit%2040M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:141:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.87
| > > > > Starting run with 4 Workers... completed with speed 0.99
| > > > > Starting run with 3 Workers... completed with speed 1.32
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']

| Current File: Test Jellyfin 4K AVC 150M.mp4
| > > Current Test: 1080p - 1080p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:528:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.66
| > > > > Starting run with 2 Workers... completed with speed 1.82
| > > > > Starting run with 4 Workers... completed with speed 0.91
| > > > > Starting run with 3 Workers... completed with speed 1.21
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,528)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 2.96
| > > > > Starting run with 3 Workers... completed with speed 1.00
| > > > > Starting run with 2 Workers... completed with speed 1.47
| > > > > Test Finished, Max Pass: 2, Min Fail: 3
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 1080p
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:528:yuv420p" -c:v h264_nvenc -preset p1 -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.57
| > > > > Starting run with 4 Workers... completed with speed 0.91
| > > > > Starting run with 3 Workers... completed with speed 1.22
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,528)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx264 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 2.97
| > > > > Starting run with 3 Workers... completed with speed 1.00
| > > > > Starting run with 4 Workers... completed with speed 0.74
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 2160p - 720p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,528)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 1.05
| > > > > Starting run with 2 Workers... completed with speed 0.79
| > > > > Test Finished, Max Pass: 1, Min Fail: 2
| > > > > Failed: ['performance']
| > > > Current Device: nvidia
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -init_hw_device cuda=cu:0 -hwaccel cuda -hwaccel_output_format cuda -c:v h264_cuvid -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale_cuda=-1:528:yuv420p" -c:v hevc_nvenc -preset p1 -b:v 3616000 -maxrate 3616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 3.58
| > > > > Starting run with 4 Workers... completed with speed 0.91
| > > > > Starting run with 3 Workers... completed with speed 1.22
| > > > > Test Finished, Max Pass: 3, Min Fail: 4
| > > > > Failed: ['performance']
| > > Current Test: 720p - 1080p
| > > > Current Device: cpu
| > > > ffmpeg command: ./jellybench_data/ffmpeg/ffmpeg_files/ffmpeg.exe -c:v h264 -i E:\\jellybench_py\\jellybench_data\\videos\\Test%20Jellyfin%204K%20AVC%20150M.mp4 -noautoscale -an -sn -vf "scale=trunc(min(max(iw\,ih*a)\,528)/2)*2:trunc(ow/a/2)*2,format=yuv420p" -c:v libx265 -preset veryfast -b:v 9616000 -maxrate 9616000 -f null - -benchmark
| > > > > Starting run with 1 Workers... completed with speed 0.70
| > > > > Failed: ['limited']
Traceback (most recent call last):
  File "<frozen runpy>", line 198, in _run_module_as_main
  File "<frozen runpy>", line 88, in _run_code
  File "E:\jellybench_py\.venv\Scripts\jellybench.exe\__main__.py", line 10, in <module>
    sys.exit(main())
             ~~~~^^
  File "E:\jellybench_py\src\jellybench_py\core.py", line 1134, in main
    return cli()
  File "E:\jellybench_py\src\jellybench_py\core.py", line 1093, in cli
    valid, runs, result = benchmark(
                          ~~~~~~~~~^
        test_cmd, debug=args.debug_flag, prog_bar=prog_bar, limit=limit
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    )
    ^
  File "E:\jellybench_py\src\jellybench_py\core.py", line 398, in benchmark
    "single_worker_speed": max_pass_run_data["speed"],
                           ~~~~~~~~~~~~~~~~~^^^^^^^^^
KeyError: 'speed'

Steps to Reproduce

1. Install uv 0.9.2 using chocolatey
2. Clone jellybench into root directory, ensuring development branch is active
3. Pin Python 3.13 using uv python pin 3.13
4. Run uv sync
5. Run uv run pre-commit install
6. Run uv run jellybench --debug

Operating System

Windows 11 Pro 24H2

System Architecture

64-bit

Python Version

3.13.8

CPU

AMD Ryzen 5 2600 Six-Core Processor (3.40 GHz)

GPU

NVIDIA GeForce GTX 1060 6GB