{"id":19745241,"url":"https://github.com/crypticsignal/video-quality-metrics","last_synced_at":"2025-04-30T07:34:09.037Z","repository":{"id":37673916,"uuid":"278952534","full_name":"CrypticSignal/video-quality-metrics","owner":"CrypticSignal","description":"Test specified presets/CRF values for the x264 or x265 encoder. Compares VMAF/SSIM/PSNR numerically \u0026 via graphs.","archived":false,"fork":false,"pushed_at":"2022-09-11T11:37:01.000Z","size":23210,"stargazers_count":114,"open_issues_count":0,"forks_count":18,"subscribers_count":5,"default_branch":"master","last_synced_at":"2024-08-02T15:59:39.016Z","etag":null,"topics":["av1","avc","crf","encode","encoder","ffmpeg","hevc","presets","psnr","quality","ssim","transcode","transcoder","video","vmaf","x264","x265"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/CrypticSignal.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2020-07-11T22:37:02.000Z","updated_at":"2024-07-26T09:29:24.000Z","dependencies_parsed_at":"2022-08-29T23:20:29.996Z","dependency_job_id":null,"html_url":"https://github.com/CrypticSignal/video-quality-metrics","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CrypticSignal%2Fvideo-quality-metrics","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CrypticSignal%2Fvideo-quality-metrics/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CrypticSignal%2Fvideo-quality-metrics/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CrypticSignal%2Fvideo-quality-metrics/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/CrypticSignal","download_url":"https://codeload.github.com/CrypticSignal/video-quality-metrics/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":224202877,"owners_count":17272807,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["av1","avc","crf","encode","encoder","ffmpeg","hevc","presets","psnr","quality","ssim","transcode","transcoder","video","vmaf","x264","x265"],"created_at":"2024-11-12T02:05:59.183Z","updated_at":"2025-04-30T07:34:09.031Z","avatar_url":"https://github.com/CrypticSignal.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Video Quality Metrics (VQM)\nVQM is a command line program that has 2 main modes:\n\n**[1] Transcoding Mode**\n\nDetails about **Transcoding Mode**, as well as example commands, can be found in the [Transcoding Mode](#transcoding-mode) section.\n\n**[2] No Transcoding Mode (`-ntm`)** \n\nVQM will calculate the VMAF (and optionally) the SSIM and PSNR of a transcoded video as long as you have the original video as well. To calculate SSIM and PSNR in addition to VMAF, you must use the `-ssim` and `-psnr` arguments.\n\nTo see an example of how to use **No Transcoding Mode**, check out the [Getting Started](#getting-started) section.\n\n# Quick Links\n- [What does VQM produce?](#what-does-vqm-produce)\n- [Getting Started](#getting-started)\n- [Transcoding Mode](#transcoding-mode)\n- [Overview Mode](#overview-mode)\n- [Combination Mode](#combination-mode)\n- [Available Arguments](#available-arguments)\n- [Requirements](#requirements)\n- [FFmpeg Builds](#ffmpeg-builds)\n- [About the model files](#about-the-model-files)\n\n# What does VQM produce?\nVQM produces a table to show the metrics, and graphs that show the variation of the value of the quality metric throughout the video (on a per-frame basis).\n\nThe table can be found in a file named `metrics_table.txt` and it contains the following:\n- Encoder parameter (only applicable if using **Transcoding Mode**)\n- Time taken to transcode the video (only applicable if using **Transcoding Mode**)\n- Filesize (MB)\n- Bitrate (Mbps)\n- [Video Multimethod Assessment Fusion (VMAF)](https://github.com/Netflix/vmaf) values. VMAF is a perceptual video quality assessment algorithm developed by Netflix.\n- [Optional] Peak Signal-to-Noise-Ratio (PSNR). _You must use the `-psnr` argument._\n- [Optional] Structural Similarity Index (SSIM). _You must use the `-ssim` argument._\n- [Optional] Multi-Scale Structural Similarity Index (MS-SSIM). _You must use the `-msssim` argument._\n```\nVMAF/PSNR/SSIM values are in the format: Min | Standard Deviation | Mean\n+-----------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n|   preset  | Encoding Time (s) |   Size  |  Bitrate  |         VMAF         |         PSNR         |        SSIM        |\n+-----------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n|  veryslow |        2.10       | 1.29 MB | 1.73 Mbps | 90.48 | 1.02 | 99.70 | 35.33 | 0.80 | 38.34 | 0.98 | 0.00 | 0.99 |\n|   slower  |        1.21       | 1.36 MB | 1.81 Mbps | 91.56 | 0.91 | 99.75 | 35.52 | 0.79 | 38.52 | 0.98 | 0.00 | 0.99 |\n|    slow   |        0.65       | 1.55 MB | 2.06 Mbps | 91.38 | 1.30 | 99.35 | 35.18 | 1.20 | 37.97 | 0.98 | 0.00 | 0.99 |\n|   medium  |        0.40       | 1.56 MB | 2.08 Mbps | 90.92 | 1.46 | 99.23 | 35.14 | 1.19 | 37.91 | 0.98 | 0.00 | 0.99 |\n|    fast   |        0.34       | 1.59 MB | 2.13 Mbps | 90.82 | 1.70 | 99.01 | 35.08 | 1.19 | 37.83 | 0.98 | 0.00 | 0.99 |\n|   faster  |        0.26       | 1.57 MB | 2.09 Mbps | 90.09 | 1.82 | 98.90 | 35.01 | 1.20 | 37.87 | 0.98 | 0.00 | 0.99 |\n|  veryfast |        0.21       | 1.57 MB | 2.09 Mbps | 88.10 | 3.15 | 96.82 | 34.18 | 1.17 | 36.81 | 0.97 | 0.00 | 0.98 |\n| superfast |        0.15       | 1.87 MB | 2.50 Mbps | 87.64 | 3.60 | 95.11 | 33.39 | 1.24 | 35.71 | 0.97 | 0.00 | 0.98 |\n| ultrafast |        0.11       | 3.72 MB | 4.97 Mbps | 92.80 | 1.65 | 98.60 | 34.50 | 0.98 | 35.94 | 0.97 | 0.00 | 0.98 |\n+-----------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\nOriginal File: Seeking_30_480_1050.mp4\nOriginal Bitrate: 1.04 Mbps\nVQM transcoded the file with the libx264 encoder\nlibvmaf n_subsample: 1\n```\nThe following command was used to produce such a table:\n```\npython main.py -i test_videos/Seeking_30_480_1050.mp4 -e libx264 -p preset -v veryslow slower slow medium fast faster veryfast superfast ultrafast -ssim -psnr\n```\n\nIn **No Transcoding Mode**, a graph is created which shows the variation of the VMAF/SSIM/PSNR throughout the video. [1]\n\nIn **Transcoding Mode**, two types of graphs are created:\n\n- A graph where the average VMAF is plotted against the value of the encoder parameter. [2]\n- A graph for each encoder parameter value, showing the variation of the VMAF/SSIM/PSNR throughout the video. [1]\n\nHere's an example of graph type [1]. This graph shows the variation of the VMAF score throughout the video:\n\n![VMAF variation graph](https://github.com/CrypticSignal/video-quality-metrics/blob/master/example_graphs/VMAF.png)\n\n_An example of the per-frame SSIM graph and per-frame PSNR graph can be found in the [example_graphs folder](https://github.com/CrypticSignal/video-quality-metrics/tree/master/example_graphs)._\n\nHere's an example of graph type [2]. This is the kind of graph that will be produced if you opted to compare the effects of different CRF values:\n\n![CRF vs VMAF graph](https://github.com/CrypticSignal/video-quality-metrics/blob/master/example_graphs/CRF%20vs%20VMAF.png)\n\n# Getting Started\nClone this repository. Then, navigate to the root of this repository in your terminal and run `pip install -r requirements.txt --upgrade`.\nVQM is now ready to be used.\n\nIf you would like to test VQM without using your own video(s), you can use the videos in the `test_videos` folder.\n\n`Seeking_30_480_1050.mp4` is the original video and `Seeking_10_288_375.mp4` is the distorted video.\n\nThere is also `ForBiggerFun.mp4`, which is a video that is exactly 1 minute long.\n\nTo test **No Transcoding Mode**, you can run:\n```\npython main.py -ntm -i test_videos/Seeking_30_480_1050.mp4 -tv test_videos/Seeking_10_288_375.mp4 -s 720x480\n```\n_Note: If using the `Seeking_...` videos in the test_videos folder, `-s 720x480` is necessary to scale the distorted video to match the resolution of the original video (720x480) before calculating VMAF scores. This is the best practice as per Netflix's tech blog. Here is a quote from [their blog](https://netflixtechblog.com/vmaf-the-journey-continues-44b51ee9ed12):_\n\n_\"A typical encoding pipeline for adaptive streaming introduces two types of artifacts — compression artifacts (due to lossy compression) and scaling artifacts (for low bitrates, source video is downsampled before compression, and later upsampled on the display device). When using VMAF to evaluate perceptual quality, both types of artifacts must be taken into account. For example, when a source is 1080p but the encode is 480p, the correct way of calculating VMAF on the pair is to upsample the encode to 1080p to match the source’s resolution. If, instead, the source is downsampled to 480p to match the encode, the obtained VMAF score will not capture the scaling artifacts.\"_\n\n_If the transcoded file is the same resolution as the original file, using the `-s` argument is not necessary._\n\nTo test **Transcoding Mode**, you can run:\n```\npython main.py -i test_videos/Seeking_30_480_1050.mp4 -e libx264 -p preset -v slow medium -ssim -psnr\n```\nAlternatively, you can use `test_videos/ForBiggerFun.mp4`.\n\n# Transcoding Mode\nIn this mode, VQM will compare the VMAF (and optionally) the SSIM and PSNR achieved with different values of the chosen encoder parameter.\n\nYou must specify an encoder (using the `-e` argument. If not specified, `libx264` will be used), a FFmpeg encoder parameter (e.g. `-preset`, `-crf`, `-quality`) and the values you want to compare (using the `-v` argument). \n\nExamples: \n\n```\npython main.py -i test_videos/Seeking_30_480_1050.mp4 -e libx265 -p preset -v slow medium\n```\n```\npython main.py -i test_videos/Seeking_30_480_1050.mp4 -e libx264 -p crf -v 22 23 24\n```\n```\npython main.py -i test_videos/Seeking_30_480_1050.mp4 -e h264_amf -p quality -v balanced speed quality\n```\n\nVQM will automatically transcode the video with each value. To calculate SSIM and PSNR in addition to VMAF, you must include the `-ssim` and `-psnr` arguments.\n\nHere is  an example of the table that is produced when comparing presets:\n```\nVMAF/PSNR/SSIM values are in the format: Min | Standard Deviation | Mean\n+--------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n| Preset | Encoding Time (s) |   Size  |  Bitrate  |         VMAF         |         PSNR         |        SSIM        |\n+--------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n|  slow  |        2.75       | 4.23 MB | 2.15 Mbps | 90.56 | 1.13 | 94.09 | 46.24 | 0.91 | 48.30 | 1.00 | 0.00 | 1.00 |\n| medium |        2.14       | 4.33 MB | 2.20 Mbps | 90.65 | 1.07 | 93.95 | 46.17 | 0.92 | 48.24 | 1.00 | 0.00 | 1.00 |\n+--------+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n```\n\nHere is  an example of the table that is produced when comparing CRF values:\n```\nVMAF/PSNR/SSIM values are in the format: Min | Standard Deviation | Mean\n+-----+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n| CRF | Encoding Time (s) |   Size  |  Bitrate  |         VMAF         |         PSNR         |        SSIM        |\n+-----+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n|  20 |        2.43       | 6.70 MB | 3.40 Mbps | 92.90 | 1.13 | 95.77 | 47.80 | 1.08 | 50.44 | 1.00 | 0.00 | 1.00 |\n|  23 |        2.13       | 4.33 MB | 2.20 Mbps | 90.65 | 1.07 | 93.95 | 46.17 | 0.92 | 48.24 | 1.00 | 0.00 | 1.00 |\n+-----+-------------------+---------+-----------+----------------------+----------------------+--------------------+\n```\n\n# Overview Mode\nOverview Mode can be used with **Transcoding Mode** by specifying the `--interval` and `--clip-length` arguments. The benefit of this mode is especially apparent with long videos, such as movies. What this mode does is create a lossless \"overview video\" by grabbing a `\u003cclip length\u003e` seconds long segment every `\u003cinterval\u003e` seconds from the original video. The transcodes and computation of the quality metrics are done using this overview video instead of the original video. As the overview video can be much shorter than the original, the process of trancoding and computing the quality metrics is much quicker, while still being a fairly accurate representation of the original video as the program goes through the whole video and grabs, say, a two-second-long segment every 60 seconds.\n\nExample: `python main.py -i test_videos/Seeking_30_480_1050.mp4 -crf 17 18 19 --interval 60 --clip-length 2`\n\nIn the example above, we're grabbing a two-second-long clip (`--clip-length 2`) every minute (`--interval 60`) in the video. These 2-second long clips are concatenated to make the overview video. A 1-hour long video is turned into an overview video that is 1 minute and 58 seconds long. The benefit of overview mode should now be clear - transcoding and computing the quality metrics of a \u003c2 minutes long video is **much** quicker than doing so with an hour long video.\n\n_An alternative method of reducing the execution time of this program is by only using the first x seconds of the original video (you can do this with the `-t` argument), but **Overview Mode** provides a better representation of the whole video._\n\n# Combination Mode\nInstead of comparing the quality achieved with various values of one encoder parameter, Combination Mode allows you to compare the quality achieved with a combination of two or more parameters.\n\nTo activate Combination Mode, specify the `-c` or `--combinations` argument, followed by a list of combinations you wish to compare. The list of combinations must be surrounded in quotes, and each combination must be separated by a comma.\n\nFor example, if you want to compare the quality achieved with:\n- The combination of preset `veryslow` and a CRF value of `18`\n- The combination of preset `slower` and CRF value of `16`\n\nYou would run something like:\n```\npython main.py -i \"test_videos/ForBiggerFun.mp4\" -e libx265 -c \"preset veryslow crf 18,preset slower crf 16\"\n```\nThe table produced will look something like this:\n```\nVMAF values are in the format: Min | Standard Deviation | Mean\n+--------------------------+-------------------+----------+-----------+----------------------+\n|       Combination        | Encoding Time (s) |   Size   |  Bitrate  |         VMAF         |\n+--------------------------+-------------------+----------+-----------+----------------------+\n| -preset veryslow -crf 18 |       325.79      | 19.13 MB | 2.55 Mbps | 94.99 | 1.27 | 99.06 |\n|  -preset slower -crf 16  |       211.81      | 24.06 MB | 3.20 Mbps | 95.62 | 1.14 | 99.23 |\n+--------------------------+-------------------+----------+-----------+----------------------+\n```\n- Combination Mode can be used alongside Overview Mode.\n- You need to decide whether you want to use the regular mode, which compares the quality metrics achieved with various values of **one** particular encoder parameter (using the `-p` and `-v` arguments), OR Combination Mode. You cannot do both.\n\n# Available Arguments\nYou can see a list of the available arguments with `python main.py -h`:\n\n```\nusage: main.py [-h] [-dp DECIMAL_PLACES] -i INPUT_VIDEO [-t TRANSCODE_LENGTH] [-ntm] [-o OUTPUT_FOLDER] [-tv TRANSCODED_VIDEO] [-vf VIDEO_FILTERS] [--av1-cpu-used \u003c1-8\u003e] [-e ENCODER] [-eo ENCODER_OPTIONS] [-p PARAMETER] [-v VALUES [VALUES ...]] [-c COMBINATIONS] [-cl \u003c1-60\u003e]\n               [--interval \u003c1-600\u003e] [-n \u003cx\u003e] [--n-threads N_THREADS] [--phone-model] [-s SCALE] [-psnr] [-ssim] [-msssim]\n\noptions:\n  -h, --help            show this help message and exit\n\nGeneral Arguments:\n  -dp, --decimal-places DECIMAL_PLACES\n                        The number of decimal places to use for the data in the table\n  -i, --input-video INPUT_VIDEO\n                        Input video. Can be a relative or absolute path, or a URL.\n                        If the path contains a space, it must be surrounded in double quotes.\n  -t, --transcode-length TRANSCODE_LENGTH\n                        Create a lossless version of the original video that is just the first x seconds of the video.\n                        This cut version of the original video is what will be transcoded and used as the reference video.\n                        You cannot use this option in conjunction with the --interval or -cl argument.\n  -ntm, --no-transcoding-mode\n                        Enable 'No Transcoding Mode', which allows you to calculate the VMAF/SSIM/PSNR for a video that you have already transcoded.\n                        The original and transcoded video paths must be specified using the -i and -tv arguments, respectively.\n                        Example: python main.py -ntm -i original.mp4 -tv transcoded.mp4\n  -o, --output-folder OUTPUT_FOLDER\n                        Use this argument if you want a specific name for the output folder. If you want the name of the output folder to contain a space, the string must be surrounded in double quotes\n  -tv, --transcoded-video TRANSCODED_VIDEO\n                        Transcoded video. Can be a relative or absolute path, or an URL. Only applicable when using the -ntm mode.\n  -vf, --video-filters VIDEO_FILTERS\n                        Apply video filter(s) to the original video before calculating quality metrics. Each filter must be separated by a comma.\n                        Example: -vf bwdif=mode=0,crop=1920:800:0:140\n\nEncoder Arguments:\n  --av1-cpu-used \u003c1-8\u003e  Only applicable if the libaom-av1 (AV1) encoder is chosen. Set the quality/encoding speed tradeoff.\n                        Lower values mean slower encoding but better quality, and vice-versa\n  -e, --encoder ENCODER\n                        Specify an ffmpeg video encoder.\n                        Examples: libx265, h264_amf, libaom-av1\n  -eo, --encoder-options ENCODER_OPTIONS\n                        Set general encoder options to use for all transcodes.\n                        Use FFmpeg syntax. Must be surronded in quotes. Example:\n                        --encoder-options='-crf 18 -x264-params keyint=123:min-keyint=20'\n  -p, --parameter PARAMETER\n                        The encoder parameter to compare, e.g. preset, crf, quality.\n                        Example: -p preset\n  -v, --values VALUES [VALUES ...]\n                        The values of the specified encoder parameter to compare. Must be used alongside the -p option. Examples:\n                        Compare presets: -p preset -v slow fast\n                        Compare CRF values: -p crf -v 22 23\n                        Compare h264_amf quality levels: -p quality -v balanced speed\n  -c, --combinations COMBINATIONS\n                        Use this mode if you want to compare the quality achieved with a combination of two or more parameters.\n                        The list of combinations must be surrounded in quotes, and each combination must be separated by a comma.\n                        For example, if you want to compare the combination of preset veryslow and CRF 18, with the combination of preset slower and CRF 16:\n                        -c 'preset veryslow crf 18,preset slower crf 16'\n\nOverview Mode Arguments:\n  -cl, --clip-length \u003c1-60\u003e\n                        When using Overview Mode, a X seconds long segment is taken from the original video every --interval seconds and these segments are concatenated to create the overview video.\n                        Specify a value for X (in the range 1-60)\n  --interval \u003c1-600\u003e    To activate Overview Mode, this argument must be specified.\n                        Overview Mode creates a lossless overview video by grabbing a --clip-length long segment every X seconds from the original video.\n                        Specify a value for X (in the range 1-600)\n\nVMAF Arguments:\n  -n, --n-subsample \u003cx\u003e\n                        Set a value for libvmaf's n_subsample option if you only want the VMAF/SSIM/PSNR to be calculated for every nth frame.\n                        Without this argument, VMAF/SSIM/PSNR scores will be calculated for every frame.\n  --n-threads N_THREADS\n                        Specify the number of threads to use when calculating VMAF\n  --phone-model         Enable VMAF phone model\n  -s, --scale SCALE     Scale the transcoded video to match the resolution of the original video.\n                        To ensure accurate VMAF scores, this is necessary if the transcoded video has a different resolution.\n                        For example, if the original video is 1920x1980 and the transcoded video is 1280x720, you should specify:\n                        -s 1920x1080\n\nOptional Metrics:\n  -psnr, --calculate-psnr\n                        Enable PSNR calculation in addition to VMAF\n  -ssim, --calculate-ssim\n                        Enable SSIM calculation in addition to VMAF\n  -msssim, --calculate-msssim\n                        Enable MS-SSIM calculation in addition to VMAF\n```\n\n# Requirements\n1. Python **3.7+** installed and in your PATH.\n2. `pip install -r requirements.txt --upgrade`\n3. FFmpeg and FFprobe installed and in your PATH (or in the same directory as this program). Your build of FFmpeg must have v2.1.1 (or above) of the `libvmaf` filter. FFmpeg must also be built with support for the encoders you wish you test.\n\nYou can check which encoders your build of FFmpeg supports by running `ffmpeg -buildconf` in the terminal.\n\nIf `--enable-libvmaf` is not printed when running `ffmpeg -buildconf`, your build of FFmpeg is not sufficient as VQM needs the `libvmaf` filter.\n\n# FFmpeg Builds\nFor convenience, below are links to FFmpeg builds that support the `libvmaf` filter. \n\n**Windows:** https://www.gyan.dev/ffmpeg/builds/ffmpeg-git-essentials.7z\n\n**macOS:** https://evermeet.cx/ffmpeg - download both ffmpeg and ffprobe and add the binaries to your PATH.\n\nAlternatively, you can install FFmpeg using Homebrew - `brew install ffmpeg`\n\n**Linux (kernels 3.2.0+):** https://johnvansickle.com/ffmpeg.\n\nDownload the _git master_ build. Installation instructions, as well as how to add FFmpeg and FFprobe to your PATH, can be found [here](https://www.johnvansickle.com/ffmpeg/faq/).\n\n# About the model files\nTwo model files are provided, `vmaf_v0.6.1.json` and `vmaf_4k_v0.6.1.json`. There is also the phone model that can be enabled by using the `-pm` argument.\n\nThis program uses the `vmaf_v0.6.1.json` model file by default, which is \"based on the assumption that the viewers sit in front of a 1080p display in a living room-like environment with the viewing distance of 3x the screen height (3H).\"\n\nThe phone model was created because the original model \"did not accurately reflect how a viewer perceives quality on a phone. In particular, due to smaller screen size and longer viewing distance relative to the screen height (\u003e3H), viewers perceive high-quality videos with smaller noticeable differences. For example, on a mobile phone, there is less distinction between 720p and 1080p videos compared to other devices. With this in mind, we trained and released a VMAF phone model.\"\n\nThe 4K model (`vmaf_4k_v0.6.1.json`) \"predicts the subjective quality of video displayed on a 4K TV and viewed from a distance of 1.5H. A viewing distance of 1.5H is the maximum distance for the average viewer to appreciate the sharpness of 4K content. The 4K model is similar to the default model in the sense that both models capture quality at the critical angular frequency of 1/60 degree/pixel. However, the 4K model assumes a wider viewing angle, which affects the foveal vs peripheral vision that the subject uses.\"\n\nThe source of the quoted text, plus additional information about VMAF (such as the correct way to calculate VMAF), can be found [here](https://netflixtechblog.com/vmaf-the-journey-continues-44b51ee9ed12).\n\n**Notes:**\n- If you are transcoding a video that will be viewed on a mobile phone, you can add the `-pm` argument which will enable the [phone model](https://github.com/Netflix/vmaf/blob/master/resource/doc/models.md/#predict-quality-on-a-cellular-phone-screen).\n\n- If you are transcoding a video that will be viewed on a 4K display, the default model (`vmaf_v0.6.1.json`) is fine if you are only interested in relative VMAF scores, i.e. the score differences between different encoder parameter values, but if you are interested in absolute scores, it may be better to use the 4K model file which predicts the subjective quality of video displayed on a 4K screen at a distance of 1.5x the height of the screen. To use the 4K model, replace the value of the `model_file_path` variable in libvmaf.py with `'vmaf_models/vmaf_4k_v0.6.1.json'`.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrypticsignal%2Fvideo-quality-metrics","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcrypticsignal%2Fvideo-quality-metrics","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrypticsignal%2Fvideo-quality-metrics/lists"}